// +build !minimal

#pragma once

#ifndef GO_QTNETWORK_H
#define GO_QTNETWORK_H

#include <stdint.h>

#ifdef __cplusplus
extern "C" {
#endif

struct QtNetwork_PackedString { char* data; long long len; };
struct QtNetwork_PackedList { void* data; long long len; };
void* QAbstractNetworkCache_NewQAbstractNetworkCache(void* parent);
long long QAbstractNetworkCache_CacheSize(void* ptr);
void QAbstractNetworkCache_Clear(void* ptr);
void* QAbstractNetworkCache_Data(void* ptr, void* url);
void QAbstractNetworkCache_Insert(void* ptr, void* device);
void* QAbstractNetworkCache_MetaData(void* ptr, void* url);
void* QAbstractNetworkCache_Prepare(void* ptr, void* metaData);
char QAbstractNetworkCache_Remove(void* ptr, void* url);
void QAbstractNetworkCache_UpdateMetaData(void* ptr, void* metaData);
void QAbstractNetworkCache_DestroyQAbstractNetworkCache(void* ptr);
void QAbstractNetworkCache_DestroyQAbstractNetworkCacheDefault(void* ptr);
void QAbstractNetworkCache_TimerEvent(void* ptr, void* event);
void QAbstractNetworkCache_TimerEventDefault(void* ptr, void* event);
void QAbstractNetworkCache_ChildEvent(void* ptr, void* event);
void QAbstractNetworkCache_ChildEventDefault(void* ptr, void* event);
void QAbstractNetworkCache_ConnectNotify(void* ptr, void* sign);
void QAbstractNetworkCache_ConnectNotifyDefault(void* ptr, void* sign);
void QAbstractNetworkCache_CustomEvent(void* ptr, void* event);
void QAbstractNetworkCache_CustomEventDefault(void* ptr, void* event);
void QAbstractNetworkCache_DeleteLater(void* ptr);
void QAbstractNetworkCache_DeleteLaterDefault(void* ptr);
void QAbstractNetworkCache_DisconnectNotify(void* ptr, void* sign);
void QAbstractNetworkCache_DisconnectNotifyDefault(void* ptr, void* sign);
char QAbstractNetworkCache_Event(void* ptr, void* e);
char QAbstractNetworkCache_EventDefault(void* ptr, void* e);
char QAbstractNetworkCache_EventFilter(void* ptr, void* watched, void* event);
char QAbstractNetworkCache_EventFilterDefault(void* ptr, void* watched, void* event);
void* QAbstractNetworkCache_MetaObject(void* ptr);
void* QAbstractNetworkCache_MetaObjectDefault(void* ptr);
void* QAbstractSocket_NewQAbstractSocket(long long socketType, void* parent);
void QAbstractSocket_Abort(void* ptr);
char QAbstractSocket_AtEnd(void* ptr);
char QAbstractSocket_AtEndDefault(void* ptr);
char QAbstractSocket_Bind(void* ptr, void* address, unsigned short port, long long mode);
char QAbstractSocket_Bind2(void* ptr, unsigned short port, long long mode);
long long QAbstractSocket_BytesAvailable(void* ptr);
long long QAbstractSocket_BytesAvailableDefault(void* ptr);
long long QAbstractSocket_BytesToWrite(void* ptr);
long long QAbstractSocket_BytesToWriteDefault(void* ptr);
char QAbstractSocket_CanReadLine(void* ptr);
char QAbstractSocket_CanReadLineDefault(void* ptr);
void QAbstractSocket_Close(void* ptr);
void QAbstractSocket_CloseDefault(void* ptr);
void QAbstractSocket_ConnectToHost2(void* ptr, void* address, unsigned short port, long long openMode);
void QAbstractSocket_ConnectToHost2Default(void* ptr, void* address, unsigned short port, long long openMode);
void QAbstractSocket_ConnectToHost(void* ptr, char* hostName, unsigned short port, long long openMode, long long protocol);
void QAbstractSocket_ConnectToHostDefault(void* ptr, char* hostName, unsigned short port, long long openMode, long long protocol);
void QAbstractSocket_ConnectConnected(void* ptr);
void QAbstractSocket_DisconnectConnected(void* ptr);
void QAbstractSocket_Connected(void* ptr);
void QAbstractSocket_DisconnectFromHost(void* ptr);
void QAbstractSocket_DisconnectFromHostDefault(void* ptr);
void QAbstractSocket_ConnectDisconnected(void* ptr);
void QAbstractSocket_DisconnectDisconnected(void* ptr);
void QAbstractSocket_Disconnected(void* ptr);
void QAbstractSocket_ConnectError2(void* ptr);
void QAbstractSocket_DisconnectError2(void* ptr);
void QAbstractSocket_Error2(void* ptr, long long socketError);
long long QAbstractSocket_Error(void* ptr);
char QAbstractSocket_Flush(void* ptr);
void QAbstractSocket_ConnectHostFound(void* ptr);
void QAbstractSocket_DisconnectHostFound(void* ptr);
void QAbstractSocket_HostFound(void* ptr);
char QAbstractSocket_IsSequential(void* ptr);
char QAbstractSocket_IsSequentialDefault(void* ptr);
char QAbstractSocket_IsValid(void* ptr);
void* QAbstractSocket_LocalAddress(void* ptr);
unsigned short QAbstractSocket_LocalPort(void* ptr);
long long QAbstractSocket_PauseMode(void* ptr);
void* QAbstractSocket_PeerAddress(void* ptr);
struct QtNetwork_PackedString QAbstractSocket_PeerName(void* ptr);
unsigned short QAbstractSocket_PeerPort(void* ptr);
void* QAbstractSocket_Proxy(void* ptr);
void QAbstractSocket_ConnectProxyAuthenticationRequired(void* ptr);
void QAbstractSocket_DisconnectProxyAuthenticationRequired(void* ptr);
void QAbstractSocket_ProxyAuthenticationRequired(void* ptr, void* proxy, void* authenticator);
long long QAbstractSocket_ReadBufferSize(void* ptr);
long long QAbstractSocket_ReadLineData(void* ptr, char* data, long long maxlen);
long long QAbstractSocket_ReadLineDataDefault(void* ptr, char* data, long long maxlen);
void QAbstractSocket_Resume(void* ptr);
void QAbstractSocket_ResumeDefault(void* ptr);
void QAbstractSocket_SetLocalAddress(void* ptr, void* address);
void QAbstractSocket_SetLocalPort(void* ptr, unsigned short port);
void QAbstractSocket_SetPauseMode(void* ptr, long long pauseMode);
void QAbstractSocket_SetPeerAddress(void* ptr, void* address);
void QAbstractSocket_SetPeerName(void* ptr, char* name);
void QAbstractSocket_SetPeerPort(void* ptr, unsigned short port);
void QAbstractSocket_SetProxy(void* ptr, void* networkProxy);
void QAbstractSocket_SetReadBufferSize(void* ptr, long long size);
void QAbstractSocket_SetReadBufferSizeDefault(void* ptr, long long size);
;
;
void QAbstractSocket_SetSocketError(void* ptr, long long socketError);
void QAbstractSocket_SetSocketOption(void* ptr, long long option, void* value);
void QAbstractSocket_SetSocketOptionDefault(void* ptr, long long option, void* value);
void QAbstractSocket_SetSocketState(void* ptr, long long state);
;
;
void* QAbstractSocket_SocketOption(void* ptr, long long option);
void* QAbstractSocket_SocketOptionDefault(void* ptr, long long option);
long long QAbstractSocket_SocketType(void* ptr);
long long QAbstractSocket_State(void* ptr);
void QAbstractSocket_ConnectStateChanged(void* ptr);
void QAbstractSocket_DisconnectStateChanged(void* ptr);
void QAbstractSocket_StateChanged(void* ptr, long long socketState);
char QAbstractSocket_WaitForBytesWritten(void* ptr, int msecs);
char QAbstractSocket_WaitForBytesWrittenDefault(void* ptr, int msecs);
char QAbstractSocket_WaitForConnected(void* ptr, int msecs);
char QAbstractSocket_WaitForConnectedDefault(void* ptr, int msecs);
char QAbstractSocket_WaitForDisconnected(void* ptr, int msecs);
char QAbstractSocket_WaitForDisconnectedDefault(void* ptr, int msecs);
char QAbstractSocket_WaitForReadyRead(void* ptr, int msecs);
char QAbstractSocket_WaitForReadyReadDefault(void* ptr, int msecs);
long long QAbstractSocket_WriteData(void* ptr, char* data, long long size);
long long QAbstractSocket_WriteDataDefault(void* ptr, char* data, long long size);
void QAbstractSocket_DestroyQAbstractSocket(void* ptr);
void QAbstractSocket_DestroyQAbstractSocketDefault(void* ptr);
char QAbstractSocket_Open(void* ptr, long long mode);
char QAbstractSocket_OpenDefault(void* ptr, long long mode);
long long QAbstractSocket_Pos(void* ptr);
long long QAbstractSocket_PosDefault(void* ptr);
char QAbstractSocket_Reset(void* ptr);
char QAbstractSocket_ResetDefault(void* ptr);
char QAbstractSocket_Seek(void* ptr, long long pos);
char QAbstractSocket_SeekDefault(void* ptr, long long pos);
long long QAbstractSocket_Size(void* ptr);
long long QAbstractSocket_SizeDefault(void* ptr);
void QAbstractSocket_TimerEvent(void* ptr, void* event);
void QAbstractSocket_TimerEventDefault(void* ptr, void* event);
void QAbstractSocket_ChildEvent(void* ptr, void* event);
void QAbstractSocket_ChildEventDefault(void* ptr, void* event);
void QAbstractSocket_ConnectNotify(void* ptr, void* sign);
void QAbstractSocket_ConnectNotifyDefault(void* ptr, void* sign);
void QAbstractSocket_CustomEvent(void* ptr, void* event);
void QAbstractSocket_CustomEventDefault(void* ptr, void* event);
void QAbstractSocket_DeleteLater(void* ptr);
void QAbstractSocket_DeleteLaterDefault(void* ptr);
void QAbstractSocket_DisconnectNotify(void* ptr, void* sign);
void QAbstractSocket_DisconnectNotifyDefault(void* ptr, void* sign);
char QAbstractSocket_Event(void* ptr, void* e);
char QAbstractSocket_EventDefault(void* ptr, void* e);
char QAbstractSocket_EventFilter(void* ptr, void* watched, void* event);
char QAbstractSocket_EventFilterDefault(void* ptr, void* watched, void* event);
void* QAbstractSocket_MetaObject(void* ptr);
void* QAbstractSocket_MetaObjectDefault(void* ptr);
void* QAuthenticator_NewQAuthenticator();
void* QAuthenticator_NewQAuthenticator2(void* other);
char QAuthenticator_IsNull(void* ptr);
void* QAuthenticator_Option(void* ptr, char* opt);
struct QtNetwork_PackedString QAuthenticator_Password(void* ptr);
struct QtNetwork_PackedString QAuthenticator_Realm(void* ptr);
void QAuthenticator_SetOption(void* ptr, char* opt, void* value);
void QAuthenticator_SetPassword(void* ptr, char* password);
void QAuthenticator_SetUser(void* ptr, char* user);
struct QtNetwork_PackedString QAuthenticator_User(void* ptr);
void QAuthenticator_DestroyQAuthenticator(void* ptr);
void* QDnsDomainNameRecord_NewQDnsDomainNameRecord();
void* QDnsDomainNameRecord_NewQDnsDomainNameRecord2(void* other);
struct QtNetwork_PackedString QDnsDomainNameRecord_Name(void* ptr);
void QDnsDomainNameRecord_Swap(void* ptr, void* other);
unsigned int QDnsDomainNameRecord_TimeToLive(void* ptr);
struct QtNetwork_PackedString QDnsDomainNameRecord_Value(void* ptr);
void QDnsDomainNameRecord_DestroyQDnsDomainNameRecord(void* ptr);
void* QDnsHostAddressRecord_NewQDnsHostAddressRecord();
void* QDnsHostAddressRecord_NewQDnsHostAddressRecord2(void* other);
struct QtNetwork_PackedString QDnsHostAddressRecord_Name(void* ptr);
void QDnsHostAddressRecord_Swap(void* ptr, void* other);
unsigned int QDnsHostAddressRecord_TimeToLive(void* ptr);
void* QDnsHostAddressRecord_Value(void* ptr);
void QDnsHostAddressRecord_DestroyQDnsHostAddressRecord(void* ptr);
void* QDnsLookup_NewQDnsLookup3(long long ty, char* name, void* nameserver, void* parent);
long long QDnsLookup_Error(void* ptr);
struct QtNetwork_PackedString QDnsLookup_ErrorString(void* ptr);
struct QtNetwork_PackedString QDnsLookup_Name(void* ptr);
void* QDnsLookup_Nameserver(void* ptr);
void QDnsLookup_SetName(void* ptr, char* name);
void QDnsLookup_SetNameserver(void* ptr, void* nameserver);
void QDnsLookup_SetType(void* ptr, long long vqd);
long long QDnsLookup_Type(void* ptr);
void* QDnsLookup_NewQDnsLookup(void* parent);
void* QDnsLookup_NewQDnsLookup2(long long ty, char* name, void* parent);
void QDnsLookup_Abort(void* ptr);
struct QtNetwork_PackedList QDnsLookup_CanonicalNameRecords(void* ptr);
void QDnsLookup_ConnectFinished(void* ptr);
void QDnsLookup_DisconnectFinished(void* ptr);
void QDnsLookup_Finished(void* ptr);
struct QtNetwork_PackedList QDnsLookup_HostAddressRecords(void* ptr);
char QDnsLookup_IsFinished(void* ptr);
void QDnsLookup_Lookup(void* ptr);
struct QtNetwork_PackedList QDnsLookup_MailExchangeRecords(void* ptr);
void QDnsLookup_ConnectNameChanged(void* ptr);
void QDnsLookup_DisconnectNameChanged(void* ptr);
void QDnsLookup_NameChanged(void* ptr, char* name);
struct QtNetwork_PackedList QDnsLookup_NameServerRecords(void* ptr);
void QDnsLookup_ConnectNameserverChanged(void* ptr);
void QDnsLookup_DisconnectNameserverChanged(void* ptr);
void QDnsLookup_NameserverChanged(void* ptr, void* nameserver);
struct QtNetwork_PackedList QDnsLookup_PointerRecords(void* ptr);
struct QtNetwork_PackedList QDnsLookup_ServiceRecords(void* ptr);
struct QtNetwork_PackedList QDnsLookup_TextRecords(void* ptr);
void QDnsLookup_ConnectTypeChanged(void* ptr);
void QDnsLookup_DisconnectTypeChanged(void* ptr);
void QDnsLookup_TypeChanged(void* ptr, long long ty);
void QDnsLookup_DestroyQDnsLookup(void* ptr);
void* QDnsLookup_canonicalNameRecords_atList(void* ptr, int i);
void* QDnsLookup_hostAddressRecords_atList(void* ptr, int i);
void* QDnsLookup_mailExchangeRecords_atList(void* ptr, int i);
void* QDnsLookup_nameServerRecords_atList(void* ptr, int i);
void* QDnsLookup_pointerRecords_atList(void* ptr, int i);
void* QDnsLookup_serviceRecords_atList(void* ptr, int i);
void* QDnsLookup_textRecords_atList(void* ptr, int i);
void QDnsLookup_TimerEvent(void* ptr, void* event);
void QDnsLookup_TimerEventDefault(void* ptr, void* event);
void QDnsLookup_ChildEvent(void* ptr, void* event);
void QDnsLookup_ChildEventDefault(void* ptr, void* event);
void QDnsLookup_ConnectNotify(void* ptr, void* sign);
void QDnsLookup_ConnectNotifyDefault(void* ptr, void* sign);
void QDnsLookup_CustomEvent(void* ptr, void* event);
void QDnsLookup_CustomEventDefault(void* ptr, void* event);
void QDnsLookup_DeleteLater(void* ptr);
void QDnsLookup_DeleteLaterDefault(void* ptr);
void QDnsLookup_DisconnectNotify(void* ptr, void* sign);
void QDnsLookup_DisconnectNotifyDefault(void* ptr, void* sign);
char QDnsLookup_Event(void* ptr, void* e);
char QDnsLookup_EventDefault(void* ptr, void* e);
char QDnsLookup_EventFilter(void* ptr, void* watched, void* event);
char QDnsLookup_EventFilterDefault(void* ptr, void* watched, void* event);
void* QDnsLookup_MetaObject(void* ptr);
void* QDnsLookup_MetaObjectDefault(void* ptr);
void* QDnsMailExchangeRecord_NewQDnsMailExchangeRecord();
void* QDnsMailExchangeRecord_NewQDnsMailExchangeRecord2(void* other);
struct QtNetwork_PackedString QDnsMailExchangeRecord_Exchange(void* ptr);
struct QtNetwork_PackedString QDnsMailExchangeRecord_Name(void* ptr);
unsigned short QDnsMailExchangeRecord_Preference(void* ptr);
void QDnsMailExchangeRecord_Swap(void* ptr, void* other);
unsigned int QDnsMailExchangeRecord_TimeToLive(void* ptr);
void QDnsMailExchangeRecord_DestroyQDnsMailExchangeRecord(void* ptr);
void* QDnsServiceRecord_NewQDnsServiceRecord();
void* QDnsServiceRecord_NewQDnsServiceRecord2(void* other);
struct QtNetwork_PackedString QDnsServiceRecord_Name(void* ptr);
unsigned short QDnsServiceRecord_Port(void* ptr);
unsigned short QDnsServiceRecord_Priority(void* ptr);
void QDnsServiceRecord_Swap(void* ptr, void* other);
struct QtNetwork_PackedString QDnsServiceRecord_Target(void* ptr);
unsigned int QDnsServiceRecord_TimeToLive(void* ptr);
unsigned short QDnsServiceRecord_Weight(void* ptr);
void QDnsServiceRecord_DestroyQDnsServiceRecord(void* ptr);
void* QDnsTextRecord_NewQDnsTextRecord();
void* QDnsTextRecord_NewQDnsTextRecord2(void* other);
struct QtNetwork_PackedString QDnsTextRecord_Name(void* ptr);
void QDnsTextRecord_Swap(void* ptr, void* other);
unsigned int QDnsTextRecord_TimeToLive(void* ptr);
struct QtNetwork_PackedList QDnsTextRecord_Values(void* ptr);
void QDnsTextRecord_DestroyQDnsTextRecord(void* ptr);
void* QDnsTextRecord_values_atList(void* ptr, int i);
void* QHostAddress_NewQHostAddress();
void* QHostAddress_NewQHostAddress9(long long address);
void* QHostAddress_NewQHostAddress8(void* address);
void* QHostAddress_NewQHostAddress7(char* address);
void* QHostAddress_NewQHostAddress4(char* ip6Addr);
void* QHostAddress_NewQHostAddress2(unsigned int ip4Addr);
void* QHostAddress_NewQHostAddress3(char* ip6Addr);
void QHostAddress_Clear(void* ptr);
char QHostAddress_IsInSubnet(void* ptr, void* subnet, int netmask);
char QHostAddress_IsLoopback(void* ptr);
char QHostAddress_IsMulticast(void* ptr);
char QHostAddress_IsNull(void* ptr);
long long QHostAddress_Protocol(void* ptr);
struct QtNetwork_PackedString QHostAddress_ScopeId(void* ptr);
char QHostAddress_SetAddress6(void* ptr, char* address);
void QHostAddress_SetAddress3(void* ptr, char* ip6Addr);
void QHostAddress_SetAddress(void* ptr, unsigned int ip4Addr);
void QHostAddress_SetAddress2(void* ptr, char* ip6Addr);
void QHostAddress_SetScopeId(void* ptr, char* id);
void QHostAddress_Swap(void* ptr, void* other);
unsigned int QHostAddress_ToIPv4Address(void* ptr);
unsigned int QHostAddress_ToIPv4Address2(void* ptr, char ok);
struct QtNetwork_PackedString QHostAddress_ToString(void* ptr);
void QHostAddress_DestroyQHostAddress(void* ptr);
struct QtNetwork_PackedString QHostInfo_QHostInfo_LocalHostName();
void* QHostInfo_NewQHostInfo2(void* other);
void* QHostInfo_NewQHostInfo(int id);
void QHostInfo_QHostInfo_AbortHostLookup(int id);
struct QtNetwork_PackedList QHostInfo_Addresses(void* ptr);
long long QHostInfo_Error(void* ptr);
struct QtNetwork_PackedString QHostInfo_ErrorString(void* ptr);
void* QHostInfo_QHostInfo_FromName(char* name);
struct QtNetwork_PackedString QHostInfo_HostName(void* ptr);
int QHostInfo_QHostInfo_LookupHost(char* name, void* receiver, char* member);
int QHostInfo_LookupId(void* ptr);
void QHostInfo_SetError(void* ptr, long long error);
void QHostInfo_SetErrorString(void* ptr, char* str);
void QHostInfo_SetHostName(void* ptr, char* hostName);
void QHostInfo_SetLookupId(void* ptr, int id);
void QHostInfo_DestroyQHostInfo(void* ptr);
struct QtNetwork_PackedString QHostInfo_QHostInfo_LocalDomainName();
void* QHostInfo_addresses_atList(void* ptr, int i);
void* QHttpMultiPart_NewQHttpMultiPart2(long long contentType, void* parent);
void* QHttpMultiPart_NewQHttpMultiPart(void* parent);
void QHttpMultiPart_Append(void* ptr, void* httpPart);
void* QHttpMultiPart_Boundary(void* ptr);
void QHttpMultiPart_SetBoundary(void* ptr, void* boundary);
void QHttpMultiPart_SetContentType(void* ptr, long long contentType);
void QHttpMultiPart_DestroyQHttpMultiPart(void* ptr);
void QHttpMultiPart_TimerEvent(void* ptr, void* event);
void QHttpMultiPart_TimerEventDefault(void* ptr, void* event);
void QHttpMultiPart_ChildEvent(void* ptr, void* event);
void QHttpMultiPart_ChildEventDefault(void* ptr, void* event);
void QHttpMultiPart_ConnectNotify(void* ptr, void* sign);
void QHttpMultiPart_ConnectNotifyDefault(void* ptr, void* sign);
void QHttpMultiPart_CustomEvent(void* ptr, void* event);
void QHttpMultiPart_CustomEventDefault(void* ptr, void* event);
void QHttpMultiPart_DeleteLater(void* ptr);
void QHttpMultiPart_DeleteLaterDefault(void* ptr);
void QHttpMultiPart_DisconnectNotify(void* ptr, void* sign);
void QHttpMultiPart_DisconnectNotifyDefault(void* ptr, void* sign);
char QHttpMultiPart_Event(void* ptr, void* e);
char QHttpMultiPart_EventDefault(void* ptr, void* e);
char QHttpMultiPart_EventFilter(void* ptr, void* watched, void* event);
char QHttpMultiPart_EventFilterDefault(void* ptr, void* watched, void* event);
void* QHttpMultiPart_MetaObject(void* ptr);
void* QHttpMultiPart_MetaObjectDefault(void* ptr);
void* QHttpPart_NewQHttpPart();
void* QHttpPart_NewQHttpPart2(void* other);
void QHttpPart_SetBody(void* ptr, void* body);
void QHttpPart_SetBodyDevice(void* ptr, void* device);
void QHttpPart_SetHeader(void* ptr, long long header, void* value);
void QHttpPart_SetRawHeader(void* ptr, void* headerName, void* headerValue);
void QHttpPart_Swap(void* ptr, void* other);
void QHttpPart_DestroyQHttpPart(void* ptr);
void QLocalServer_SetSocketOptions(void* ptr, long long options);
void* QLocalServer_NewQLocalServer(void* parent);
void QLocalServer_Close(void* ptr);
struct QtNetwork_PackedString QLocalServer_ErrorString(void* ptr);
struct QtNetwork_PackedString QLocalServer_FullServerName(void* ptr);
char QLocalServer_HasPendingConnections(void* ptr);
char QLocalServer_HasPendingConnectionsDefault(void* ptr);
void QLocalServer_IncomingConnection(void* ptr, uintptr_t socketDescriptor);
void QLocalServer_IncomingConnectionDefault(void* ptr, uintptr_t socketDescriptor);
char QLocalServer_IsListening(void* ptr);
char QLocalServer_Listen(void* ptr, char* name);
int QLocalServer_MaxPendingConnections(void* ptr);
void QLocalServer_ConnectNewConnection(void* ptr);
void QLocalServer_DisconnectNewConnection(void* ptr);
void QLocalServer_NewConnection(void* ptr);
void* QLocalServer_NextPendingConnection(void* ptr);
void* QLocalServer_NextPendingConnectionDefault(void* ptr);
char QLocalServer_QLocalServer_RemoveServer(char* name);
long long QLocalServer_ServerError(void* ptr);
struct QtNetwork_PackedString QLocalServer_ServerName(void* ptr);
void QLocalServer_SetMaxPendingConnections(void* ptr, int numConnections);
long long QLocalServer_SocketOptions(void* ptr);
char QLocalServer_WaitForNewConnection(void* ptr, int msec, char timedOut);
void QLocalServer_DestroyQLocalServer(void* ptr);
void QLocalServer_TimerEvent(void* ptr, void* event);
void QLocalServer_TimerEventDefault(void* ptr, void* event);
void QLocalServer_ChildEvent(void* ptr, void* event);
void QLocalServer_ChildEventDefault(void* ptr, void* event);
void QLocalServer_ConnectNotify(void* ptr, void* sign);
void QLocalServer_ConnectNotifyDefault(void* ptr, void* sign);
void QLocalServer_CustomEvent(void* ptr, void* event);
void QLocalServer_CustomEventDefault(void* ptr, void* event);
void QLocalServer_DeleteLater(void* ptr);
void QLocalServer_DeleteLaterDefault(void* ptr);
void QLocalServer_DisconnectNotify(void* ptr, void* sign);
void QLocalServer_DisconnectNotifyDefault(void* ptr, void* sign);
char QLocalServer_Event(void* ptr, void* e);
char QLocalServer_EventDefault(void* ptr, void* e);
char QLocalServer_EventFilter(void* ptr, void* watched, void* event);
char QLocalServer_EventFilterDefault(void* ptr, void* watched, void* event);
void* QLocalServer_MetaObject(void* ptr);
void* QLocalServer_MetaObjectDefault(void* ptr);
char QLocalSocket_Open(void* ptr, long long openMode);
char QLocalSocket_OpenDefault(void* ptr, long long openMode);
void* QLocalSocket_NewQLocalSocket(void* parent);
void QLocalSocket_ConnectToServer2(void* ptr, char* name, long long openMode);
void QLocalSocket_ConnectConnected(void* ptr);
void QLocalSocket_DisconnectConnected(void* ptr);
void QLocalSocket_Connected(void* ptr);
void QLocalSocket_ConnectDisconnected(void* ptr);
void QLocalSocket_DisconnectDisconnected(void* ptr);
void QLocalSocket_Disconnected(void* ptr);
void QLocalSocket_ConnectError2(void* ptr);
void QLocalSocket_DisconnectError2(void* ptr);
void QLocalSocket_Error2(void* ptr, long long socketError);
struct QtNetwork_PackedString QLocalSocket_FullServerName(void* ptr);
char QLocalSocket_IsSequential(void* ptr);
char QLocalSocket_IsSequentialDefault(void* ptr);
struct QtNetwork_PackedString QLocalSocket_ServerName(void* ptr);
void QLocalSocket_SetServerName(void* ptr, char* name);
long long QLocalSocket_State(void* ptr);
void QLocalSocket_ConnectStateChanged(void* ptr);
void QLocalSocket_DisconnectStateChanged(void* ptr);
void QLocalSocket_StateChanged(void* ptr, long long socketState);
void QLocalSocket_DestroyQLocalSocket(void* ptr);
void QLocalSocket_Abort(void* ptr);
long long QLocalSocket_BytesAvailable(void* ptr);
long long QLocalSocket_BytesAvailableDefault(void* ptr);
long long QLocalSocket_BytesToWrite(void* ptr);
long long QLocalSocket_BytesToWriteDefault(void* ptr);
char QLocalSocket_CanReadLine(void* ptr);
char QLocalSocket_CanReadLineDefault(void* ptr);
void QLocalSocket_Close(void* ptr);
void QLocalSocket_CloseDefault(void* ptr);
void QLocalSocket_ConnectToServer(void* ptr, long long openMode);
void QLocalSocket_DisconnectFromServer(void* ptr);
long long QLocalSocket_Error(void* ptr);
char QLocalSocket_Flush(void* ptr);
char QLocalSocket_IsValid(void* ptr);
long long QLocalSocket_ReadBufferSize(void* ptr);
void QLocalSocket_SetReadBufferSize(void* ptr, long long size);
char QLocalSocket_WaitForBytesWritten(void* ptr, int msecs);
char QLocalSocket_WaitForBytesWrittenDefault(void* ptr, int msecs);
char QLocalSocket_WaitForConnected(void* ptr, int msecs);
char QLocalSocket_WaitForDisconnected(void* ptr, int msecs);
char QLocalSocket_WaitForReadyRead(void* ptr, int msecs);
char QLocalSocket_WaitForReadyReadDefault(void* ptr, int msecs);
long long QLocalSocket_WriteData(void* ptr, char* data, long long c);
long long QLocalSocket_WriteDataDefault(void* ptr, char* data, long long c);
char QLocalSocket_AtEnd(void* ptr);
char QLocalSocket_AtEndDefault(void* ptr);
long long QLocalSocket_Pos(void* ptr);
long long QLocalSocket_PosDefault(void* ptr);
long long QLocalSocket_ReadLineData(void* ptr, char* data, long long maxSize);
long long QLocalSocket_ReadLineDataDefault(void* ptr, char* data, long long maxSize);
char QLocalSocket_Reset(void* ptr);
char QLocalSocket_ResetDefault(void* ptr);
char QLocalSocket_Seek(void* ptr, long long pos);
char QLocalSocket_SeekDefault(void* ptr, long long pos);
long long QLocalSocket_Size(void* ptr);
long long QLocalSocket_SizeDefault(void* ptr);
void QLocalSocket_TimerEvent(void* ptr, void* event);
void QLocalSocket_TimerEventDefault(void* ptr, void* event);
void QLocalSocket_ChildEvent(void* ptr, void* event);
void QLocalSocket_ChildEventDefault(void* ptr, void* event);
void QLocalSocket_ConnectNotify(void* ptr, void* sign);
void QLocalSocket_ConnectNotifyDefault(void* ptr, void* sign);
void QLocalSocket_CustomEvent(void* ptr, void* event);
void QLocalSocket_CustomEventDefault(void* ptr, void* event);
void QLocalSocket_DeleteLater(void* ptr);
void QLocalSocket_DeleteLaterDefault(void* ptr);
void QLocalSocket_DisconnectNotify(void* ptr, void* sign);
void QLocalSocket_DisconnectNotifyDefault(void* ptr, void* sign);
char QLocalSocket_Event(void* ptr, void* e);
char QLocalSocket_EventDefault(void* ptr, void* e);
char QLocalSocket_EventFilter(void* ptr, void* watched, void* event);
char QLocalSocket_EventFilterDefault(void* ptr, void* watched, void* event);
void* QLocalSocket_MetaObject(void* ptr);
void* QLocalSocket_MetaObjectDefault(void* ptr);
void* QNetworkAccessManager_ProxyFactory(void* ptr);
void* QNetworkAccessManager_NewQNetworkAccessManager(void* parent);
void* QNetworkAccessManager_ActiveConfiguration(void* ptr);
void QNetworkAccessManager_ConnectAuthenticationRequired(void* ptr);
void QNetworkAccessManager_DisconnectAuthenticationRequired(void* ptr);
void QNetworkAccessManager_AuthenticationRequired(void* ptr, void* reply, void* authenticator);
void* QNetworkAccessManager_Cache(void* ptr);
void QNetworkAccessManager_ClearAccessCache(void* ptr);
void* QNetworkAccessManager_Configuration(void* ptr);
void QNetworkAccessManager_ConnectToHost(void* ptr, char* hostName, unsigned short port);
void QNetworkAccessManager_ConnectToHostEncrypted(void* ptr, char* hostName, unsigned short port, void* sslConfiguration);
void* QNetworkAccessManager_CookieJar(void* ptr);
void* QNetworkAccessManager_CreateRequest(void* ptr, long long op, void* req, void* outgoingData);
void* QNetworkAccessManager_CreateRequestDefault(void* ptr, long long op, void* req, void* outgoingData);
void* QNetworkAccessManager_DeleteResource(void* ptr, void* request);
void QNetworkAccessManager_ConnectEncrypted(void* ptr);
void QNetworkAccessManager_DisconnectEncrypted(void* ptr);
void QNetworkAccessManager_Encrypted(void* ptr, void* reply);
void QNetworkAccessManager_ConnectFinished(void* ptr);
void QNetworkAccessManager_DisconnectFinished(void* ptr);
void QNetworkAccessManager_Finished(void* ptr, void* reply);
void* QNetworkAccessManager_Get(void* ptr, void* request);
void* QNetworkAccessManager_Head(void* ptr, void* request);
long long QNetworkAccessManager_NetworkAccessible(void* ptr);
void QNetworkAccessManager_ConnectNetworkAccessibleChanged(void* ptr);
void QNetworkAccessManager_DisconnectNetworkAccessibleChanged(void* ptr);
void QNetworkAccessManager_NetworkAccessibleChanged(void* ptr, long long accessible);
void* QNetworkAccessManager_Post3(void* ptr, void* request, void* multiPart);
void* QNetworkAccessManager_Post(void* ptr, void* request, void* data);
void* QNetworkAccessManager_Post2(void* ptr, void* request, void* data);
void QNetworkAccessManager_ConnectPreSharedKeyAuthenticationRequired(void* ptr);
void QNetworkAccessManager_DisconnectPreSharedKeyAuthenticationRequired(void* ptr);
void QNetworkAccessManager_PreSharedKeyAuthenticationRequired(void* ptr, void* reply, void* authenticator);
void* QNetworkAccessManager_Proxy(void* ptr);
void QNetworkAccessManager_ConnectProxyAuthenticationRequired(void* ptr);
void QNetworkAccessManager_DisconnectProxyAuthenticationRequired(void* ptr);
void QNetworkAccessManager_ProxyAuthenticationRequired(void* ptr, void* proxy, void* authenticator);
void* QNetworkAccessManager_Put3(void* ptr, void* request, void* multiPart);
void* QNetworkAccessManager_Put(void* ptr, void* request, void* data);
void* QNetworkAccessManager_Put2(void* ptr, void* request, void* data);
void* QNetworkAccessManager_SendCustomRequest(void* ptr, void* request, void* verb, void* data);
void QNetworkAccessManager_SetCache(void* ptr, void* cache);
void QNetworkAccessManager_SetConfiguration(void* ptr, void* config);
void QNetworkAccessManager_SetCookieJar(void* ptr, void* cookieJar);
void QNetworkAccessManager_SetNetworkAccessible(void* ptr, long long accessible);
void QNetworkAccessManager_SetProxy(void* ptr, void* proxy);
void QNetworkAccessManager_SetProxyFactory(void* ptr, void* factory);
struct QtNetwork_PackedString QNetworkAccessManager_SupportedSchemes(void* ptr);
struct QtNetwork_PackedString QNetworkAccessManager_SupportedSchemesImplementation(void* ptr);
void QNetworkAccessManager_DestroyQNetworkAccessManager(void* ptr);
void QNetworkAccessManager_TimerEvent(void* ptr, void* event);
void QNetworkAccessManager_TimerEventDefault(void* ptr, void* event);
void QNetworkAccessManager_ChildEvent(void* ptr, void* event);
void QNetworkAccessManager_ChildEventDefault(void* ptr, void* event);
void QNetworkAccessManager_ConnectNotify(void* ptr, void* sign);
void QNetworkAccessManager_ConnectNotifyDefault(void* ptr, void* sign);
void QNetworkAccessManager_CustomEvent(void* ptr, void* event);
void QNetworkAccessManager_CustomEventDefault(void* ptr, void* event);
void QNetworkAccessManager_DeleteLater(void* ptr);
void QNetworkAccessManager_DeleteLaterDefault(void* ptr);
void QNetworkAccessManager_DisconnectNotify(void* ptr, void* sign);
void QNetworkAccessManager_DisconnectNotifyDefault(void* ptr, void* sign);
char QNetworkAccessManager_Event(void* ptr, void* e);
char QNetworkAccessManager_EventDefault(void* ptr, void* e);
char QNetworkAccessManager_EventFilter(void* ptr, void* watched, void* event);
char QNetworkAccessManager_EventFilterDefault(void* ptr, void* watched, void* event);
void* QNetworkAccessManager_MetaObject(void* ptr);
void* QNetworkAccessManager_MetaObjectDefault(void* ptr);
void* QNetworkAddressEntry_NewQNetworkAddressEntry();
void* QNetworkAddressEntry_NewQNetworkAddressEntry2(void* other);
void* QNetworkAddressEntry_Broadcast(void* ptr);
void* QNetworkAddressEntry_Ip(void* ptr);
void* QNetworkAddressEntry_Netmask(void* ptr);
int QNetworkAddressEntry_PrefixLength(void* ptr);
void QNetworkAddressEntry_SetBroadcast(void* ptr, void* newBroadcast);
void QNetworkAddressEntry_SetIp(void* ptr, void* newIp);
void QNetworkAddressEntry_SetNetmask(void* ptr, void* newNetmask);
void QNetworkAddressEntry_SetPrefixLength(void* ptr, int length);
void QNetworkAddressEntry_Swap(void* ptr, void* other);
void QNetworkAddressEntry_DestroyQNetworkAddressEntry(void* ptr);
void* QNetworkCacheMetaData_NewQNetworkCacheMetaData();
void* QNetworkCacheMetaData_NewQNetworkCacheMetaData2(void* other);
void* QNetworkCacheMetaData_ExpirationDate(void* ptr);
char QNetworkCacheMetaData_IsValid(void* ptr);
void* QNetworkCacheMetaData_LastModified(void* ptr);
char QNetworkCacheMetaData_SaveToDisk(void* ptr);
void QNetworkCacheMetaData_SetExpirationDate(void* ptr, void* dateTime);
void QNetworkCacheMetaData_SetLastModified(void* ptr, void* dateTime);
void QNetworkCacheMetaData_SetSaveToDisk(void* ptr, char allow);
void QNetworkCacheMetaData_SetUrl(void* ptr, void* url);
void QNetworkCacheMetaData_Swap(void* ptr, void* other);
void* QNetworkCacheMetaData_Url(void* ptr);
void QNetworkCacheMetaData_DestroyQNetworkCacheMetaData(void* ptr);
void* QNetworkConfiguration_NewQNetworkConfiguration();
void* QNetworkConfiguration_NewQNetworkConfiguration2(void* other);
long long QNetworkConfiguration_BearerType(void* ptr);
long long QNetworkConfiguration_BearerTypeFamily(void* ptr);
struct QtNetwork_PackedString QNetworkConfiguration_BearerTypeName(void* ptr);
struct QtNetwork_PackedList QNetworkConfiguration_Children(void* ptr);
struct QtNetwork_PackedString QNetworkConfiguration_Identifier(void* ptr);
char QNetworkConfiguration_IsRoamingAvailable(void* ptr);
char QNetworkConfiguration_IsValid(void* ptr);
struct QtNetwork_PackedString QNetworkConfiguration_Name(void* ptr);
long long QNetworkConfiguration_Purpose(void* ptr);
long long QNetworkConfiguration_State(void* ptr);
void QNetworkConfiguration_Swap(void* ptr, void* other);
long long QNetworkConfiguration_Type(void* ptr);
void QNetworkConfiguration_DestroyQNetworkConfiguration(void* ptr);
void* QNetworkConfiguration_children_atList(void* ptr, int i);
void* QNetworkConfigurationManager_NewQNetworkConfigurationManager(void* parent);
struct QtNetwork_PackedList QNetworkConfigurationManager_AllConfigurations(void* ptr, long long filter);
long long QNetworkConfigurationManager_Capabilities(void* ptr);
void QNetworkConfigurationManager_ConnectConfigurationAdded(void* ptr);
void QNetworkConfigurationManager_DisconnectConfigurationAdded(void* ptr);
void QNetworkConfigurationManager_ConfigurationAdded(void* ptr, void* config);
void QNetworkConfigurationManager_ConnectConfigurationChanged(void* ptr);
void QNetworkConfigurationManager_DisconnectConfigurationChanged(void* ptr);
void QNetworkConfigurationManager_ConfigurationChanged(void* ptr, void* config);
void* QNetworkConfigurationManager_ConfigurationFromIdentifier(void* ptr, char* identifier);
void QNetworkConfigurationManager_ConnectConfigurationRemoved(void* ptr);
void QNetworkConfigurationManager_DisconnectConfigurationRemoved(void* ptr);
void QNetworkConfigurationManager_ConfigurationRemoved(void* ptr, void* config);
void* QNetworkConfigurationManager_DefaultConfiguration(void* ptr);
char QNetworkConfigurationManager_IsOnline(void* ptr);
void QNetworkConfigurationManager_ConnectOnlineStateChanged(void* ptr);
void QNetworkConfigurationManager_DisconnectOnlineStateChanged(void* ptr);
void QNetworkConfigurationManager_OnlineStateChanged(void* ptr, char isOnline);
void QNetworkConfigurationManager_ConnectUpdateCompleted(void* ptr);
void QNetworkConfigurationManager_DisconnectUpdateCompleted(void* ptr);
void QNetworkConfigurationManager_UpdateCompleted(void* ptr);
void QNetworkConfigurationManager_UpdateConfigurations(void* ptr);
void QNetworkConfigurationManager_DestroyQNetworkConfigurationManager(void* ptr);
void QNetworkConfigurationManager_DestroyQNetworkConfigurationManagerDefault(void* ptr);
void* QNetworkConfigurationManager_allConfigurations_atList(void* ptr, int i);
void QNetworkConfigurationManager_TimerEvent(void* ptr, void* event);
void QNetworkConfigurationManager_TimerEventDefault(void* ptr, void* event);
void QNetworkConfigurationManager_ChildEvent(void* ptr, void* event);
void QNetworkConfigurationManager_ChildEventDefault(void* ptr, void* event);
void QNetworkConfigurationManager_ConnectNotify(void* ptr, void* sign);
void QNetworkConfigurationManager_ConnectNotifyDefault(void* ptr, void* sign);
void QNetworkConfigurationManager_CustomEvent(void* ptr, void* event);
void QNetworkConfigurationManager_CustomEventDefault(void* ptr, void* event);
void QNetworkConfigurationManager_DeleteLater(void* ptr);
void QNetworkConfigurationManager_DeleteLaterDefault(void* ptr);
void QNetworkConfigurationManager_DisconnectNotify(void* ptr, void* sign);
void QNetworkConfigurationManager_DisconnectNotifyDefault(void* ptr, void* sign);
char QNetworkConfigurationManager_Event(void* ptr, void* e);
char QNetworkConfigurationManager_EventDefault(void* ptr, void* e);
char QNetworkConfigurationManager_EventFilter(void* ptr, void* watched, void* event);
char QNetworkConfigurationManager_EventFilterDefault(void* ptr, void* watched, void* event);
void* QNetworkConfigurationManager_MetaObject(void* ptr);
void* QNetworkConfigurationManager_MetaObjectDefault(void* ptr);
void* QNetworkCookie_NewQNetworkCookie(void* name, void* value);
void* QNetworkCookie_NewQNetworkCookie2(void* other);
struct QtNetwork_PackedString QNetworkCookie_Domain(void* ptr);
void* QNetworkCookie_ExpirationDate(void* ptr);
char QNetworkCookie_HasSameIdentifier(void* ptr, void* other);
char QNetworkCookie_IsHttpOnly(void* ptr);
char QNetworkCookie_IsSecure(void* ptr);
char QNetworkCookie_IsSessionCookie(void* ptr);
void* QNetworkCookie_Name(void* ptr);
void QNetworkCookie_Normalize(void* ptr, void* url);
struct QtNetwork_PackedList QNetworkCookie_QNetworkCookie_ParseCookies(void* cookieString);
struct QtNetwork_PackedString QNetworkCookie_Path(void* ptr);
void QNetworkCookie_SetDomain(void* ptr, char* domain);
void QNetworkCookie_SetExpirationDate(void* ptr, void* date);
void QNetworkCookie_SetHttpOnly(void* ptr, char enable);
void QNetworkCookie_SetName(void* ptr, void* cookieName);
void QNetworkCookie_SetPath(void* ptr, char* path);
void QNetworkCookie_SetSecure(void* ptr, char enable);
void QNetworkCookie_SetValue(void* ptr, void* value);
void QNetworkCookie_Swap(void* ptr, void* other);
void* QNetworkCookie_ToRawForm(void* ptr, long long form);
void* QNetworkCookie_Value(void* ptr);
void QNetworkCookie_DestroyQNetworkCookie(void* ptr);
void* QNetworkCookie_parseCookies_atList(void* ptr, int i);
void* QNetworkCookieJar_NewQNetworkCookieJar(void* parent);
struct QtNetwork_PackedList QNetworkCookieJar_AllCookies(void* ptr);
struct QtNetwork_PackedList QNetworkCookieJar_CookiesForUrl(void* ptr, void* url);
char QNetworkCookieJar_DeleteCookie(void* ptr, void* cookie);
char QNetworkCookieJar_DeleteCookieDefault(void* ptr, void* cookie);
char QNetworkCookieJar_InsertCookie(void* ptr, void* cookie);
char QNetworkCookieJar_InsertCookieDefault(void* ptr, void* cookie);
char QNetworkCookieJar_UpdateCookie(void* ptr, void* cookie);
char QNetworkCookieJar_UpdateCookieDefault(void* ptr, void* cookie);
char QNetworkCookieJar_ValidateCookie(void* ptr, void* cookie, void* url);
char QNetworkCookieJar_ValidateCookieDefault(void* ptr, void* cookie, void* url);
void QNetworkCookieJar_DestroyQNetworkCookieJar(void* ptr);
void QNetworkCookieJar_DestroyQNetworkCookieJarDefault(void* ptr);
void* QNetworkCookieJar_allCookies_atList(void* ptr, int i);
void* QNetworkCookieJar_cookiesForUrl_atList(void* ptr, int i);
void QNetworkCookieJar_TimerEvent(void* ptr, void* event);
void QNetworkCookieJar_TimerEventDefault(void* ptr, void* event);
void QNetworkCookieJar_ChildEvent(void* ptr, void* event);
void QNetworkCookieJar_ChildEventDefault(void* ptr, void* event);
void QNetworkCookieJar_ConnectNotify(void* ptr, void* sign);
void QNetworkCookieJar_ConnectNotifyDefault(void* ptr, void* sign);
void QNetworkCookieJar_CustomEvent(void* ptr, void* event);
void QNetworkCookieJar_CustomEventDefault(void* ptr, void* event);
void QNetworkCookieJar_DeleteLater(void* ptr);
void QNetworkCookieJar_DeleteLaterDefault(void* ptr);
void QNetworkCookieJar_DisconnectNotify(void* ptr, void* sign);
void QNetworkCookieJar_DisconnectNotifyDefault(void* ptr, void* sign);
char QNetworkCookieJar_Event(void* ptr, void* e);
char QNetworkCookieJar_EventDefault(void* ptr, void* e);
char QNetworkCookieJar_EventFilter(void* ptr, void* watched, void* event);
char QNetworkCookieJar_EventFilterDefault(void* ptr, void* watched, void* event);
void* QNetworkCookieJar_MetaObject(void* ptr);
void* QNetworkCookieJar_MetaObjectDefault(void* ptr);
void* QNetworkDiskCache_NewQNetworkDiskCache(void* parent);
struct QtNetwork_PackedString QNetworkDiskCache_CacheDirectory(void* ptr);
long long QNetworkDiskCache_CacheSize(void* ptr);
long long QNetworkDiskCache_CacheSizeDefault(void* ptr);
void QNetworkDiskCache_Clear(void* ptr);
void QNetworkDiskCache_ClearDefault(void* ptr);
void* QNetworkDiskCache_Data(void* ptr, void* url);
void* QNetworkDiskCache_DataDefault(void* ptr, void* url);
long long QNetworkDiskCache_Expire(void* ptr);
long long QNetworkDiskCache_ExpireDefault(void* ptr);
void* QNetworkDiskCache_FileMetaData(void* ptr, char* fileName);
void QNetworkDiskCache_Insert(void* ptr, void* device);
void QNetworkDiskCache_InsertDefault(void* ptr, void* device);
long long QNetworkDiskCache_MaximumCacheSize(void* ptr);
void* QNetworkDiskCache_MetaData(void* ptr, void* url);
void* QNetworkDiskCache_MetaDataDefault(void* ptr, void* url);
void* QNetworkDiskCache_Prepare(void* ptr, void* metaData);
void* QNetworkDiskCache_PrepareDefault(void* ptr, void* metaData);
char QNetworkDiskCache_Remove(void* ptr, void* url);
char QNetworkDiskCache_RemoveDefault(void* ptr, void* url);
void QNetworkDiskCache_SetCacheDirectory(void* ptr, char* cacheDir);
void QNetworkDiskCache_SetMaximumCacheSize(void* ptr, long long size);
void QNetworkDiskCache_UpdateMetaData(void* ptr, void* metaData);
void QNetworkDiskCache_UpdateMetaDataDefault(void* ptr, void* metaData);
void QNetworkDiskCache_DestroyQNetworkDiskCache(void* ptr);
void QNetworkDiskCache_TimerEvent(void* ptr, void* event);
void QNetworkDiskCache_TimerEventDefault(void* ptr, void* event);
void QNetworkDiskCache_ChildEvent(void* ptr, void* event);
void QNetworkDiskCache_ChildEventDefault(void* ptr, void* event);
void QNetworkDiskCache_ConnectNotify(void* ptr, void* sign);
void QNetworkDiskCache_ConnectNotifyDefault(void* ptr, void* sign);
void QNetworkDiskCache_CustomEvent(void* ptr, void* event);
void QNetworkDiskCache_CustomEventDefault(void* ptr, void* event);
void QNetworkDiskCache_DeleteLater(void* ptr);
void QNetworkDiskCache_DeleteLaterDefault(void* ptr);
void QNetworkDiskCache_DisconnectNotify(void* ptr, void* sign);
void QNetworkDiskCache_DisconnectNotifyDefault(void* ptr, void* sign);
char QNetworkDiskCache_Event(void* ptr, void* e);
char QNetworkDiskCache_EventDefault(void* ptr, void* e);
char QNetworkDiskCache_EventFilter(void* ptr, void* watched, void* event);
char QNetworkDiskCache_EventFilterDefault(void* ptr, void* watched, void* event);
void* QNetworkDiskCache_MetaObject(void* ptr);
void* QNetworkDiskCache_MetaObjectDefault(void* ptr);
void* QNetworkInterface_NewQNetworkInterface();
void* QNetworkInterface_NewQNetworkInterface2(void* other);
struct QtNetwork_PackedList QNetworkInterface_AddressEntries(void* ptr);
struct QtNetwork_PackedList QNetworkInterface_QNetworkInterface_AllAddresses();
struct QtNetwork_PackedList QNetworkInterface_QNetworkInterface_AllInterfaces();
long long QNetworkInterface_Flags(void* ptr);
struct QtNetwork_PackedString QNetworkInterface_HardwareAddress(void* ptr);
struct QtNetwork_PackedString QNetworkInterface_HumanReadableName(void* ptr);
int QNetworkInterface_Index(void* ptr);
void* QNetworkInterface_QNetworkInterface_InterfaceFromIndex(int index);
void* QNetworkInterface_QNetworkInterface_InterfaceFromName(char* name);
int QNetworkInterface_QNetworkInterface_InterfaceIndexFromName(char* name);
struct QtNetwork_PackedString QNetworkInterface_QNetworkInterface_InterfaceNameFromIndex(int index);
char QNetworkInterface_IsValid(void* ptr);
struct QtNetwork_PackedString QNetworkInterface_Name(void* ptr);
void QNetworkInterface_Swap(void* ptr, void* other);
void QNetworkInterface_DestroyQNetworkInterface(void* ptr);
void* QNetworkInterface_addressEntries_atList(void* ptr, int i);
void* QNetworkInterface_allAddresses_atList(void* ptr, int i);
void* QNetworkInterface_allInterfaces_atList(void* ptr, int i);
void* QNetworkProxy_NewQNetworkProxy();
void* QNetworkProxy_NewQNetworkProxy2(long long ty, char* hostName, unsigned short port, char* user, char* password);
void* QNetworkProxy_NewQNetworkProxy3(void* other);
void* QNetworkProxy_QNetworkProxy_ApplicationProxy();
long long QNetworkProxy_Capabilities(void* ptr);
char QNetworkProxy_HasRawHeader(void* ptr, void* headerName);
void* QNetworkProxy_Header(void* ptr, long long header);
struct QtNetwork_PackedString QNetworkProxy_HostName(void* ptr);
char QNetworkProxy_IsCachingProxy(void* ptr);
char QNetworkProxy_IsTransparentProxy(void* ptr);
struct QtNetwork_PackedString QNetworkProxy_Password(void* ptr);
unsigned short QNetworkProxy_Port(void* ptr);
void* QNetworkProxy_RawHeader(void* ptr, void* headerName);
struct QtNetwork_PackedList QNetworkProxy_RawHeaderList(void* ptr);
void QNetworkProxy_QNetworkProxy_SetApplicationProxy(void* networkProxy);
void QNetworkProxy_SetCapabilities(void* ptr, long long capabilities);
void QNetworkProxy_SetHeader(void* ptr, long long header, void* value);
void QNetworkProxy_SetHostName(void* ptr, char* hostName);
void QNetworkProxy_SetPassword(void* ptr, char* password);
void QNetworkProxy_SetPort(void* ptr, unsigned short port);
void QNetworkProxy_SetRawHeader(void* ptr, void* headerName, void* headerValue);
void QNetworkProxy_SetType(void* ptr, long long ty);
void QNetworkProxy_SetUser(void* ptr, char* user);
void QNetworkProxy_Swap(void* ptr, void* other);
long long QNetworkProxy_Type(void* ptr);
struct QtNetwork_PackedString QNetworkProxy_User(void* ptr);
void QNetworkProxy_DestroyQNetworkProxy(void* ptr);
void* QNetworkProxy_rawHeaderList_atList(void* ptr, int i);
struct QtNetwork_PackedList QNetworkProxyFactory_QNetworkProxyFactory_ProxyForQuery(void* query);
struct QtNetwork_PackedList QNetworkProxyFactory_QueryProxy(void* ptr, void* query);
void QNetworkProxyFactory_QNetworkProxyFactory_SetApplicationProxyFactory(void* factory);
void QNetworkProxyFactory_QNetworkProxyFactory_SetUseSystemConfiguration(char enable);
void QNetworkProxyFactory_DestroyQNetworkProxyFactory(void* ptr);
void QNetworkProxyFactory_DestroyQNetworkProxyFactoryDefault(void* ptr);
struct QtNetwork_PackedList QNetworkProxyFactory_QNetworkProxyFactory_SystemProxyForQuery(void* query);
void* QNetworkProxyFactory_proxyForQuery_atList(void* ptr, int i);
void* QNetworkProxyFactory_queryProxy_atList(void* ptr, int i);
void* QNetworkProxyFactory_systemProxyForQuery_atList(void* ptr, int i);
void* QNetworkProxyQuery_NewQNetworkProxyQuery();
void* QNetworkProxyQuery_NewQNetworkProxyQuery6(void* networkConfiguration, char* hostname, int port, char* protocolTag, long long queryType);
void* QNetworkProxyQuery_NewQNetworkProxyQuery5(void* networkConfiguration, void* requestUrl, long long queryType);
void* QNetworkProxyQuery_NewQNetworkProxyQuery7(void* networkConfiguration, unsigned short bindPort, char* protocolTag, long long queryType);
void* QNetworkProxyQuery_NewQNetworkProxyQuery8(void* other);
void* QNetworkProxyQuery_NewQNetworkProxyQuery3(char* hostname, int port, char* protocolTag, long long queryType);
void* QNetworkProxyQuery_NewQNetworkProxyQuery2(void* requestUrl, long long queryType);
void* QNetworkProxyQuery_NewQNetworkProxyQuery4(unsigned short bindPort, char* protocolTag, long long queryType);
int QNetworkProxyQuery_LocalPort(void* ptr);
void* QNetworkProxyQuery_NetworkConfiguration(void* ptr);
struct QtNetwork_PackedString QNetworkProxyQuery_PeerHostName(void* ptr);
int QNetworkProxyQuery_PeerPort(void* ptr);
struct QtNetwork_PackedString QNetworkProxyQuery_ProtocolTag(void* ptr);
long long QNetworkProxyQuery_QueryType(void* ptr);
void QNetworkProxyQuery_SetLocalPort(void* ptr, int port);
void QNetworkProxyQuery_SetNetworkConfiguration(void* ptr, void* networkConfiguration);
void QNetworkProxyQuery_SetPeerHostName(void* ptr, char* hostname);
void QNetworkProxyQuery_SetPeerPort(void* ptr, int port);
void QNetworkProxyQuery_SetProtocolTag(void* ptr, char* protocolTag);
void QNetworkProxyQuery_SetQueryType(void* ptr, long long ty);
void QNetworkProxyQuery_SetUrl(void* ptr, void* url);
void QNetworkProxyQuery_Swap(void* ptr, void* other);
void* QNetworkProxyQuery_Url(void* ptr);
void QNetworkProxyQuery_DestroyQNetworkProxyQuery(void* ptr);
void QNetworkReply_SetSslConfigurationImplementation(void* ptr, void* configuration);
void QNetworkReply_SetSslConfigurationImplementationDefault(void* ptr, void* configuration);
void QNetworkReply_SslConfigurationImplementation(void* ptr, void* configuration);
void QNetworkReply_SslConfigurationImplementationDefault(void* ptr, void* configuration);
void QNetworkReply_Abort(void* ptr);
void* QNetworkReply_Attribute(void* ptr, long long code);
void QNetworkReply_Close(void* ptr);
void QNetworkReply_CloseDefault(void* ptr);
void QNetworkReply_ConnectDownloadProgress(void* ptr);
void QNetworkReply_DisconnectDownloadProgress(void* ptr);
void QNetworkReply_DownloadProgress(void* ptr, long long bytesReceived, long long bytesTotal);
void QNetworkReply_ConnectEncrypted(void* ptr);
void QNetworkReply_DisconnectEncrypted(void* ptr);
void QNetworkReply_Encrypted(void* ptr);
void QNetworkReply_ConnectError2(void* ptr);
void QNetworkReply_DisconnectError2(void* ptr);
void QNetworkReply_Error2(void* ptr, long long code);
long long QNetworkReply_Error(void* ptr);
void QNetworkReply_ConnectFinished(void* ptr);
void QNetworkReply_DisconnectFinished(void* ptr);
void QNetworkReply_Finished(void* ptr);
char QNetworkReply_HasRawHeader(void* ptr, void* headerName);
void* QNetworkReply_Header(void* ptr, long long header);
void QNetworkReply_IgnoreSslErrors(void* ptr);
void QNetworkReply_IgnoreSslErrorsDefault(void* ptr);
char QNetworkReply_IsFinished(void* ptr);
char QNetworkReply_IsRunning(void* ptr);
void* QNetworkReply_Manager(void* ptr);
void QNetworkReply_ConnectMetaDataChanged(void* ptr);
void QNetworkReply_DisconnectMetaDataChanged(void* ptr);
void QNetworkReply_MetaDataChanged(void* ptr);
long long QNetworkReply_Operation(void* ptr);
void QNetworkReply_ConnectPreSharedKeyAuthenticationRequired(void* ptr);
void QNetworkReply_DisconnectPreSharedKeyAuthenticationRequired(void* ptr);
void QNetworkReply_PreSharedKeyAuthenticationRequired(void* ptr, void* authenticator);
void* QNetworkReply_RawHeader(void* ptr, void* headerName);
struct QtNetwork_PackedList QNetworkReply_RawHeaderList(void* ptr);
long long QNetworkReply_ReadBufferSize(void* ptr);
void QNetworkReply_ConnectRedirected(void* ptr);
void QNetworkReply_DisconnectRedirected(void* ptr);
void QNetworkReply_Redirected(void* ptr, void* url);
void* QNetworkReply_Request(void* ptr);
void QNetworkReply_SetAttribute(void* ptr, long long code, void* value);
void QNetworkReply_SetError(void* ptr, long long errorCode, char* errorString);
void QNetworkReply_SetFinished(void* ptr, char finished);
void QNetworkReply_SetHeader(void* ptr, long long header, void* value);
void QNetworkReply_SetOperation(void* ptr, long long operation);
void QNetworkReply_SetRawHeader(void* ptr, void* headerName, void* value);
void QNetworkReply_SetReadBufferSize(void* ptr, long long size);
void QNetworkReply_SetReadBufferSizeDefault(void* ptr, long long size);
void QNetworkReply_SetRequest(void* ptr, void* request);
void QNetworkReply_SetSslConfiguration(void* ptr, void* config);
void QNetworkReply_SetUrl(void* ptr, void* url);
void* QNetworkReply_SslConfiguration(void* ptr);
void QNetworkReply_ConnectUploadProgress(void* ptr);
void QNetworkReply_DisconnectUploadProgress(void* ptr);
void QNetworkReply_UploadProgress(void* ptr, long long bytesSent, long long bytesTotal);
void* QNetworkReply_Url(void* ptr);
void QNetworkReply_DestroyQNetworkReply(void* ptr);
void* QNetworkReply_rawHeaderList_atList(void* ptr, int i);
char QNetworkReply_AtEnd(void* ptr);
char QNetworkReply_AtEndDefault(void* ptr);
long long QNetworkReply_BytesAvailable(void* ptr);
long long QNetworkReply_BytesAvailableDefault(void* ptr);
long long QNetworkReply_BytesToWrite(void* ptr);
long long QNetworkReply_BytesToWriteDefault(void* ptr);
char QNetworkReply_CanReadLine(void* ptr);
char QNetworkReply_CanReadLineDefault(void* ptr);
char QNetworkReply_IsSequential(void* ptr);
char QNetworkReply_IsSequentialDefault(void* ptr);
char QNetworkReply_Open(void* ptr, long long mode);
char QNetworkReply_OpenDefault(void* ptr, long long mode);
long long QNetworkReply_Pos(void* ptr);
long long QNetworkReply_PosDefault(void* ptr);
long long QNetworkReply_ReadLineData(void* ptr, char* data, long long maxSize);
long long QNetworkReply_ReadLineDataDefault(void* ptr, char* data, long long maxSize);
char QNetworkReply_Reset(void* ptr);
char QNetworkReply_ResetDefault(void* ptr);
char QNetworkReply_Seek(void* ptr, long long pos);
char QNetworkReply_SeekDefault(void* ptr, long long pos);
long long QNetworkReply_Size(void* ptr);
long long QNetworkReply_SizeDefault(void* ptr);
char QNetworkReply_WaitForBytesWritten(void* ptr, int msecs);
char QNetworkReply_WaitForBytesWrittenDefault(void* ptr, int msecs);
char QNetworkReply_WaitForReadyRead(void* ptr, int msecs);
char QNetworkReply_WaitForReadyReadDefault(void* ptr, int msecs);
long long QNetworkReply_WriteData(void* ptr, char* data, long long maxSize);
long long QNetworkReply_WriteDataDefault(void* ptr, char* data, long long maxSize);
void QNetworkReply_TimerEvent(void* ptr, void* event);
void QNetworkReply_TimerEventDefault(void* ptr, void* event);
void QNetworkReply_ChildEvent(void* ptr, void* event);
void QNetworkReply_ChildEventDefault(void* ptr, void* event);
void QNetworkReply_ConnectNotify(void* ptr, void* sign);
void QNetworkReply_ConnectNotifyDefault(void* ptr, void* sign);
void QNetworkReply_CustomEvent(void* ptr, void* event);
void QNetworkReply_CustomEventDefault(void* ptr, void* event);
void QNetworkReply_DeleteLater(void* ptr);
void QNetworkReply_DeleteLaterDefault(void* ptr);
void QNetworkReply_DisconnectNotify(void* ptr, void* sign);
void QNetworkReply_DisconnectNotifyDefault(void* ptr, void* sign);
char QNetworkReply_Event(void* ptr, void* e);
char QNetworkReply_EventDefault(void* ptr, void* e);
char QNetworkReply_EventFilter(void* ptr, void* watched, void* event);
char QNetworkReply_EventFilterDefault(void* ptr, void* watched, void* event);
void* QNetworkReply_MetaObject(void* ptr);
void* QNetworkReply_MetaObjectDefault(void* ptr);
void* QNetworkRequest_NewQNetworkRequest2(void* other);
void* QNetworkRequest_NewQNetworkRequest(void* url);
void* QNetworkRequest_Attribute(void* ptr, long long code, void* defaultValue);
char QNetworkRequest_HasRawHeader(void* ptr, void* headerName);
void* QNetworkRequest_Header(void* ptr, long long header);
int QNetworkRequest_MaximumRedirectsAllowed(void* ptr);
void* QNetworkRequest_OriginatingObject(void* ptr);
long long QNetworkRequest_Priority(void* ptr);
void* QNetworkRequest_RawHeader(void* ptr, void* headerName);
struct QtNetwork_PackedList QNetworkRequest_RawHeaderList(void* ptr);
void QNetworkRequest_SetAttribute(void* ptr, long long code, void* value);
void QNetworkRequest_SetHeader(void* ptr, long long header, void* value);
void QNetworkRequest_SetMaximumRedirectsAllowed(void* ptr, int maxRedirectsAllowed);
void QNetworkRequest_SetOriginatingObject(void* ptr, void* object);
void QNetworkRequest_SetPriority(void* ptr, long long priority);
void QNetworkRequest_SetRawHeader(void* ptr, void* headerName, void* headerValue);
void QNetworkRequest_SetSslConfiguration(void* ptr, void* config);
void QNetworkRequest_SetUrl(void* ptr, void* url);
void* QNetworkRequest_SslConfiguration(void* ptr);
void QNetworkRequest_Swap(void* ptr, void* other);
void* QNetworkRequest_Url(void* ptr);
void QNetworkRequest_DestroyQNetworkRequest(void* ptr);
void* QNetworkRequest_rawHeaderList_atList(void* ptr, int i);
void* QNetworkSession_NewQNetworkSession(void* connectionConfig, void* parent);
void QNetworkSession_Accept(void* ptr);
unsigned long long QNetworkSession_ActiveTime(void* ptr);
unsigned long long QNetworkSession_BytesReceived(void* ptr);
unsigned long long QNetworkSession_BytesWritten(void* ptr);
void QNetworkSession_Close(void* ptr);
void QNetworkSession_ConnectClosed(void* ptr);
void QNetworkSession_DisconnectClosed(void* ptr);
void QNetworkSession_Closed(void* ptr);
void* QNetworkSession_Configuration(void* ptr);
void QNetworkSession_ConnectError2(void* ptr);
void QNetworkSession_DisconnectError2(void* ptr);
void QNetworkSession_Error2(void* ptr, long long error);
long long QNetworkSession_Error(void* ptr);
struct QtNetwork_PackedString QNetworkSession_ErrorString(void* ptr);
void QNetworkSession_Ignore(void* ptr);
void* QNetworkSession_Interface(void* ptr);
char QNetworkSession_IsOpen(void* ptr);
void QNetworkSession_Migrate(void* ptr);
void QNetworkSession_ConnectNewConfigurationActivated(void* ptr);
void QNetworkSession_DisconnectNewConfigurationActivated(void* ptr);
void QNetworkSession_NewConfigurationActivated(void* ptr);
void QNetworkSession_Open(void* ptr);
void QNetworkSession_ConnectOpened(void* ptr);
void QNetworkSession_DisconnectOpened(void* ptr);
void QNetworkSession_Opened(void* ptr);
void QNetworkSession_ConnectPreferredConfigurationChanged(void* ptr);
void QNetworkSession_DisconnectPreferredConfigurationChanged(void* ptr);
void QNetworkSession_PreferredConfigurationChanged(void* ptr, void* config, char isSeamless);
void QNetworkSession_Reject(void* ptr);
void* QNetworkSession_SessionProperty(void* ptr, char* key);
void QNetworkSession_SetSessionProperty(void* ptr, char* key, void* value);
long long QNetworkSession_State(void* ptr);
void QNetworkSession_ConnectStateChanged(void* ptr);
void QNetworkSession_DisconnectStateChanged(void* ptr);
void QNetworkSession_StateChanged(void* ptr, long long state);
void QNetworkSession_Stop(void* ptr);
long long QNetworkSession_UsagePolicies(void* ptr);
void QNetworkSession_ConnectUsagePoliciesChanged(void* ptr);
void QNetworkSession_DisconnectUsagePoliciesChanged(void* ptr);
void QNetworkSession_UsagePoliciesChanged(void* ptr, long long usagePolicies);
char QNetworkSession_WaitForOpened(void* ptr, int msecs);
void QNetworkSession_DestroyQNetworkSession(void* ptr);
void QNetworkSession_DestroyQNetworkSessionDefault(void* ptr);
void QNetworkSession_TimerEvent(void* ptr, void* event);
void QNetworkSession_TimerEventDefault(void* ptr, void* event);
void QNetworkSession_ChildEvent(void* ptr, void* event);
void QNetworkSession_ChildEventDefault(void* ptr, void* event);
void QNetworkSession_ConnectNotify(void* ptr, void* sign);
void QNetworkSession_ConnectNotifyDefault(void* ptr, void* sign);
void QNetworkSession_CustomEvent(void* ptr, void* event);
void QNetworkSession_CustomEventDefault(void* ptr, void* event);
void QNetworkSession_DeleteLater(void* ptr);
void QNetworkSession_DeleteLaterDefault(void* ptr);
void QNetworkSession_DisconnectNotify(void* ptr, void* sign);
void QNetworkSession_DisconnectNotifyDefault(void* ptr, void* sign);
char QNetworkSession_Event(void* ptr, void* e);
char QNetworkSession_EventDefault(void* ptr, void* e);
char QNetworkSession_EventFilter(void* ptr, void* watched, void* event);
char QNetworkSession_EventFilterDefault(void* ptr, void* watched, void* event);
void* QNetworkSession_MetaObject(void* ptr);
void* QNetworkSession_MetaObjectDefault(void* ptr);
int QSsl_TlsV1_1_Type();
int QSsl_TlsV1_2_Type();
int QSsl_AnyProtocol_Type();
int QSsl_TlsV1SslV3_Type();
int QSsl_SecureProtocols_Type();
int QSsl_TlsV1_0OrLater_Type();
int QSsl_TlsV1_1OrLater_Type();
int QSsl_TlsV1_2OrLater_Type();
void* QSslCertificate_NewQSslCertificate(void* device, long long format);
void* QSslCertificate_NewQSslCertificate2(void* data, long long format);
void* QSslCertificate_NewQSslCertificate3(void* other);
void QSslCertificate_Clear(void* ptr);
void* QSslCertificate_Digest(void* ptr, long long algorithm);
struct QtNetwork_PackedList QSslCertificate_QSslCertificate_FromData(void* data, long long format);
struct QtNetwork_PackedList QSslCertificate_QSslCertificate_FromDevice(void* device, long long format);
struct QtNetwork_PackedList QSslCertificate_QSslCertificate_FromPath(char* path, long long format, long long syntax);
char QSslCertificate_IsBlacklisted(void* ptr);
void QSslCertificate_Swap(void* ptr, void* other);
void QSslCertificate_DestroyQSslCertificate(void* ptr);
void* QSslCertificate_EffectiveDate(void* ptr);
void* QSslCertificate_ExpiryDate(void* ptr);
struct QtNetwork_PackedList QSslCertificate_Extensions(void* ptr);
char QSslCertificate_IsNull(void* ptr);
char QSslCertificate_IsSelfSigned(void* ptr);
struct QtNetwork_PackedString QSslCertificate_IssuerInfo(void* ptr, long long subject);
struct QtNetwork_PackedString QSslCertificate_IssuerInfo2(void* ptr, void* attribute);
struct QtNetwork_PackedList QSslCertificate_IssuerInfoAttributes(void* ptr);
void* QSslCertificate_PublicKey(void* ptr);
void* QSslCertificate_SerialNumber(void* ptr);
struct QtNetwork_PackedString QSslCertificate_SubjectInfo(void* ptr, long long subject);
struct QtNetwork_PackedString QSslCertificate_SubjectInfo2(void* ptr, void* attribute);
struct QtNetwork_PackedList QSslCertificate_SubjectInfoAttributes(void* ptr);
void* QSslCertificate_ToDer(void* ptr);
void* QSslCertificate_ToPem(void* ptr);
struct QtNetwork_PackedString QSslCertificate_ToText(void* ptr);
void* QSslCertificate_Version(void* ptr);
void* QSslCertificate_fromData_atList(void* ptr, int i);
void* QSslCertificate_fromDevice_atList(void* ptr, int i);
void* QSslCertificate_fromPath_atList(void* ptr, int i);
void* QSslCertificate_extensions_atList(void* ptr, int i);
void* QSslCertificate_issuerInfoAttributes_atList(void* ptr, int i);
void* QSslCertificate_subjectInfoAttributes_atList(void* ptr, int i);
void* QSslCertificateExtension_NewQSslCertificateExtension();
void* QSslCertificateExtension_NewQSslCertificateExtension2(void* other);
char QSslCertificateExtension_IsCritical(void* ptr);
char QSslCertificateExtension_IsSupported(void* ptr);
struct QtNetwork_PackedString QSslCertificateExtension_Name(void* ptr);
struct QtNetwork_PackedString QSslCertificateExtension_Oid(void* ptr);
void QSslCertificateExtension_Swap(void* ptr, void* other);
void* QSslCertificateExtension_Value(void* ptr);
void QSslCertificateExtension_DestroyQSslCertificateExtension(void* ptr);
void* QSslCipher_NewQSslCipher();
void* QSslCipher_NewQSslCipher4(void* other);
void* QSslCipher_NewQSslCipher2(char* name);
void* QSslCipher_NewQSslCipher3(char* name, long long protocol);
struct QtNetwork_PackedString QSslCipher_AuthenticationMethod(void* ptr);
struct QtNetwork_PackedString QSslCipher_EncryptionMethod(void* ptr);
char QSslCipher_IsNull(void* ptr);
struct QtNetwork_PackedString QSslCipher_KeyExchangeMethod(void* ptr);
struct QtNetwork_PackedString QSslCipher_Name(void* ptr);
long long QSslCipher_Protocol(void* ptr);
struct QtNetwork_PackedString QSslCipher_ProtocolString(void* ptr);
int QSslCipher_SupportedBits(void* ptr);
void QSslCipher_Swap(void* ptr, void* other);
int QSslCipher_UsedBits(void* ptr);
void QSslCipher_DestroyQSslCipher(void* ptr);
void* QSslConfiguration_NewQSslConfiguration();
void* QSslConfiguration_NewQSslConfiguration2(void* other);
struct QtNetwork_PackedList QSslConfiguration_AllowedNextProtocols(void* ptr);
struct QtNetwork_PackedList QSslConfiguration_CaCertificates(void* ptr);
struct QtNetwork_PackedList QSslConfiguration_Ciphers(void* ptr);
void* QSslConfiguration_QSslConfiguration_DefaultConfiguration();
void* QSslConfiguration_EphemeralServerKey(void* ptr);
char QSslConfiguration_IsNull(void* ptr);
void* QSslConfiguration_LocalCertificate(void* ptr);
struct QtNetwork_PackedList QSslConfiguration_LocalCertificateChain(void* ptr);
void* QSslConfiguration_NextNegotiatedProtocol(void* ptr);
long long QSslConfiguration_NextProtocolNegotiationStatus(void* ptr);
void* QSslConfiguration_PeerCertificate(void* ptr);
struct QtNetwork_PackedList QSslConfiguration_PeerCertificateChain(void* ptr);
int QSslConfiguration_PeerVerifyDepth(void* ptr);
long long QSslConfiguration_PeerVerifyMode(void* ptr);
void* QSslConfiguration_PrivateKey(void* ptr);
long long QSslConfiguration_Protocol(void* ptr);
void* QSslConfiguration_SessionCipher(void* ptr);
long long QSslConfiguration_SessionProtocol(void* ptr);
void* QSslConfiguration_SessionTicket(void* ptr);
int QSslConfiguration_SessionTicketLifeTimeHint(void* ptr);
void QSslConfiguration_QSslConfiguration_SetDefaultConfiguration(void* configuration);
void QSslConfiguration_SetLocalCertificate(void* ptr, void* certificate);
void QSslConfiguration_SetPeerVerifyDepth(void* ptr, int depth);
void QSslConfiguration_SetPeerVerifyMode(void* ptr, long long mode);
void QSslConfiguration_SetPrivateKey(void* ptr, void* key);
void QSslConfiguration_SetProtocol(void* ptr, long long protocol);
void QSslConfiguration_SetSessionTicket(void* ptr, void* sessionTicket);
void QSslConfiguration_SetSslOption(void* ptr, long long option, char on);
struct QtNetwork_PackedList QSslConfiguration_QSslConfiguration_SupportedCiphers();
void QSslConfiguration_Swap(void* ptr, void* other);
struct QtNetwork_PackedList QSslConfiguration_QSslConfiguration_SystemCaCertificates();
char QSslConfiguration_TestSslOption(void* ptr, long long option);
void QSslConfiguration_DestroyQSslConfiguration(void* ptr);
void* QSslConfiguration_allowedNextProtocols_atList(void* ptr, int i);
void* QSslConfiguration_caCertificates_atList(void* ptr, int i);
void* QSslConfiguration_ciphers_atList(void* ptr, int i);
void* QSslConfiguration_ellipticCurves_atList(void* ptr, int i);
void* QSslConfiguration_localCertificateChain_atList(void* ptr, int i);
void* QSslConfiguration_peerCertificateChain_atList(void* ptr, int i);
void* QSslConfiguration_supportedCiphers_atList(void* ptr, int i);
void* QSslConfiguration_supportedEllipticCurves_atList(void* ptr, int i);
void* QSslConfiguration_systemCaCertificates_atList(void* ptr, int i);
void* QSslEllipticCurve_NewQSslEllipticCurve();
char QSslEllipticCurve_IsValid(void* ptr);
void* QSslEllipticCurve_QSslEllipticCurve_FromLongName(char* name);
void* QSslEllipticCurve_QSslEllipticCurve_FromShortName(char* name);
char QSslEllipticCurve_IsTlsNamedCurve(void* ptr);
struct QtNetwork_PackedString QSslEllipticCurve_LongName(void* ptr);
struct QtNetwork_PackedString QSslEllipticCurve_ShortName(void* ptr);
void* QSslError_NewQSslError();
void* QSslError_NewQSslError2(long long error);
void* QSslError_NewQSslError3(long long error, void* certificate);
void* QSslError_NewQSslError4(void* other);
void* QSslError_Certificate(void* ptr);
long long QSslError_Error(void* ptr);
struct QtNetwork_PackedString QSslError_ErrorString(void* ptr);
void QSslError_Swap(void* ptr, void* other);
void QSslError_DestroyQSslError(void* ptr);
void* QSslKey_NewQSslKey();
void* QSslKey_NewQSslKey3(void* device, long long algorithm, long long encoding, long long ty, void* passPhrase);
void* QSslKey_NewQSslKey2(void* encoded, long long algorithm, long long encoding, long long ty, void* passPhrase);
void* QSslKey_NewQSslKey5(void* other);
long long QSslKey_Algorithm(void* ptr);
void QSslKey_Clear(void* ptr);
char QSslKey_IsNull(void* ptr);
int QSslKey_Length(void* ptr);
void QSslKey_Swap(void* ptr, void* other);
void* QSslKey_ToDer(void* ptr, void* passPhrase);
void* QSslKey_ToPem(void* ptr, void* passPhrase);
long long QSslKey_Type(void* ptr);
void QSslKey_DestroyQSslKey(void* ptr);
void* QSslPreSharedKeyAuthenticator_NewQSslPreSharedKeyAuthenticator();
void* QSslPreSharedKeyAuthenticator_NewQSslPreSharedKeyAuthenticator2(void* authenticator);
void* QSslPreSharedKeyAuthenticator_Identity(void* ptr);
void* QSslPreSharedKeyAuthenticator_IdentityHint(void* ptr);
int QSslPreSharedKeyAuthenticator_MaximumIdentityLength(void* ptr);
int QSslPreSharedKeyAuthenticator_MaximumPreSharedKeyLength(void* ptr);
void* QSslPreSharedKeyAuthenticator_PreSharedKey(void* ptr);
void QSslPreSharedKeyAuthenticator_SetIdentity(void* ptr, void* identity);
void QSslPreSharedKeyAuthenticator_SetPreSharedKey(void* ptr, void* preSharedKey);
void QSslPreSharedKeyAuthenticator_Swap(void* ptr, void* authenticator);
void QSslPreSharedKeyAuthenticator_DestroyQSslPreSharedKeyAuthenticator(void* ptr);
void* QSslSocket_NewQSslSocket(void* parent);
void QSslSocket_Abort(void* ptr);
void QSslSocket_AddCaCertificate(void* ptr, void* certificate);
char QSslSocket_AddCaCertificates(void* ptr, char* path, long long format, long long syntax);
void QSslSocket_QSslSocket_AddDefaultCaCertificate(void* certificate);
char QSslSocket_QSslSocket_AddDefaultCaCertificates(char* path, long long encoding, long long syntax);
char QSslSocket_AtEnd(void* ptr);
long long QSslSocket_BytesAvailable(void* ptr);
long long QSslSocket_BytesToWrite(void* ptr);
char QSslSocket_CanReadLine(void* ptr);
void QSslSocket_Close(void* ptr);
void QSslSocket_ConnectToHostEncrypted(void* ptr, char* hostName, unsigned short port, long long mode, long long protocol);
void QSslSocket_ConnectToHostEncrypted2(void* ptr, char* hostName, unsigned short port, char* sslPeerName, long long mode, long long protocol);
void QSslSocket_ConnectEncrypted(void* ptr);
void QSslSocket_DisconnectEncrypted(void* ptr);
void QSslSocket_Encrypted(void* ptr);
long long QSslSocket_EncryptedBytesAvailable(void* ptr);
long long QSslSocket_EncryptedBytesToWrite(void* ptr);
void QSslSocket_ConnectEncryptedBytesWritten(void* ptr);
void QSslSocket_DisconnectEncryptedBytesWritten(void* ptr);
void QSslSocket_EncryptedBytesWritten(void* ptr, long long written);
char QSslSocket_Flush(void* ptr);
void QSslSocket_IgnoreSslErrors(void* ptr);
char QSslSocket_IsEncrypted(void* ptr);
void* QSslSocket_LocalCertificate(void* ptr);
struct QtNetwork_PackedList QSslSocket_LocalCertificateChain(void* ptr);
long long QSslSocket_Mode(void* ptr);
void QSslSocket_ConnectModeChanged(void* ptr);
void QSslSocket_DisconnectModeChanged(void* ptr);
void QSslSocket_ModeChanged(void* ptr, long long mode);
void* QSslSocket_PeerCertificate(void* ptr);
struct QtNetwork_PackedList QSslSocket_PeerCertificateChain(void* ptr);
int QSslSocket_PeerVerifyDepth(void* ptr);
void QSslSocket_ConnectPeerVerifyError(void* ptr);
void QSslSocket_DisconnectPeerVerifyError(void* ptr);
void QSslSocket_PeerVerifyError(void* ptr, void* error);
long long QSslSocket_PeerVerifyMode(void* ptr);
struct QtNetwork_PackedString QSslSocket_PeerVerifyName(void* ptr);
void QSslSocket_ConnectPreSharedKeyAuthenticationRequired(void* ptr);
void QSslSocket_DisconnectPreSharedKeyAuthenticationRequired(void* ptr);
void QSslSocket_PreSharedKeyAuthenticationRequired(void* ptr, void* authenticator);
void* QSslSocket_PrivateKey(void* ptr);
long long QSslSocket_Protocol(void* ptr);
void QSslSocket_Resume(void* ptr);
void QSslSocket_ResumeDefault(void* ptr);
void* QSslSocket_SessionCipher(void* ptr);
long long QSslSocket_SessionProtocol(void* ptr);
void QSslSocket_SetLocalCertificate(void* ptr, void* certificate);
void QSslSocket_SetLocalCertificate2(void* ptr, char* path, long long format);
void QSslSocket_SetPeerVerifyDepth(void* ptr, int depth);
void QSslSocket_SetPeerVerifyMode(void* ptr, long long mode);
void QSslSocket_SetPeerVerifyName(void* ptr, char* hostName);
void QSslSocket_SetPrivateKey(void* ptr, void* key);
void QSslSocket_SetPrivateKey2(void* ptr, char* fileName, long long algorithm, long long format, void* passPhrase);
void QSslSocket_SetProtocol(void* ptr, long long protocol);
void QSslSocket_SetReadBufferSize(void* ptr, long long size);
void QSslSocket_SetReadBufferSizeDefault(void* ptr, long long size);
;
;
void QSslSocket_SetSocketOption(void* ptr, long long option, void* value);
void QSslSocket_SetSocketOptionDefault(void* ptr, long long option, void* value);
void QSslSocket_SetSslConfiguration(void* ptr, void* configuration);
void* QSslSocket_SocketOption(void* ptr, long long option);
void* QSslSocket_SocketOptionDefault(void* ptr, long long option);
void* QSslSocket_SslConfiguration(void* ptr);
struct QtNetwork_PackedList QSslSocket_SslErrors(void* ptr);
long QSslSocket_QSslSocket_SslLibraryBuildVersionNumber();
struct QtNetwork_PackedString QSslSocket_QSslSocket_SslLibraryBuildVersionString();
long QSslSocket_QSslSocket_SslLibraryVersionNumber();
struct QtNetwork_PackedString QSslSocket_QSslSocket_SslLibraryVersionString();
void QSslSocket_StartClientEncryption(void* ptr);
void QSslSocket_StartServerEncryption(void* ptr);
char QSslSocket_QSslSocket_SupportsSsl();
char QSslSocket_WaitForBytesWritten(void* ptr, int msecs);
char QSslSocket_WaitForConnected(void* ptr, int msecs);
char QSslSocket_WaitForConnectedDefault(void* ptr, int msecs);
char QSslSocket_WaitForDisconnected(void* ptr, int msecs);
char QSslSocket_WaitForDisconnectedDefault(void* ptr, int msecs);
char QSslSocket_WaitForEncrypted(void* ptr, int msecs);
char QSslSocket_WaitForReadyRead(void* ptr, int msecs);
long long QSslSocket_WriteData(void* ptr, char* data, long long len);
void QSslSocket_DestroyQSslSocket(void* ptr);
void* QSslSocket_caCertificates_atList(void* ptr, int i);
void* QSslSocket_ciphers_atList(void* ptr, int i);
void* QSslSocket_defaultCaCertificates_atList(void* ptr, int i);
void* QSslSocket_defaultCiphers_atList(void* ptr, int i);
void* QSslSocket_localCertificateChain_atList(void* ptr, int i);
void* QSslSocket_peerCertificateChain_atList(void* ptr, int i);
void* QSslSocket_sslErrors_atList(void* ptr, int i);
void* QSslSocket_supportedCiphers_atList(void* ptr, int i);
void* QSslSocket_systemCaCertificates_atList(void* ptr, int i);
void QSslSocket_ConnectToHost2(void* ptr, void* address, unsigned short port, long long openMode);
void QSslSocket_ConnectToHost2Default(void* ptr, void* address, unsigned short port, long long openMode);
void QSslSocket_ConnectToHost(void* ptr, char* hostName, unsigned short port, long long openMode, long long protocol);
void QSslSocket_ConnectToHostDefault(void* ptr, char* hostName, unsigned short port, long long openMode, long long protocol);
void QSslSocket_DisconnectFromHost(void* ptr);
void QSslSocket_DisconnectFromHostDefault(void* ptr);
char QSslSocket_IsSequential(void* ptr);
char QSslSocket_IsSequentialDefault(void* ptr);
long long QSslSocket_ReadLineData(void* ptr, char* data, long long maxlen);
long long QSslSocket_ReadLineDataDefault(void* ptr, char* data, long long maxlen);
;
;
char QSslSocket_Open(void* ptr, long long mode);
char QSslSocket_OpenDefault(void* ptr, long long mode);
long long QSslSocket_Pos(void* ptr);
long long QSslSocket_PosDefault(void* ptr);
char QSslSocket_Reset(void* ptr);
char QSslSocket_ResetDefault(void* ptr);
char QSslSocket_Seek(void* ptr, long long pos);
char QSslSocket_SeekDefault(void* ptr, long long pos);
long long QSslSocket_Size(void* ptr);
long long QSslSocket_SizeDefault(void* ptr);
void QSslSocket_TimerEvent(void* ptr, void* event);
void QSslSocket_TimerEventDefault(void* ptr, void* event);
void QSslSocket_ChildEvent(void* ptr, void* event);
void QSslSocket_ChildEventDefault(void* ptr, void* event);
void QSslSocket_ConnectNotify(void* ptr, void* sign);
void QSslSocket_ConnectNotifyDefault(void* ptr, void* sign);
void QSslSocket_CustomEvent(void* ptr, void* event);
void QSslSocket_CustomEventDefault(void* ptr, void* event);
void QSslSocket_DeleteLater(void* ptr);
void QSslSocket_DeleteLaterDefault(void* ptr);
void QSslSocket_DisconnectNotify(void* ptr, void* sign);
void QSslSocket_DisconnectNotifyDefault(void* ptr, void* sign);
char QSslSocket_Event(void* ptr, void* e);
char QSslSocket_EventDefault(void* ptr, void* e);
char QSslSocket_EventFilter(void* ptr, void* watched, void* event);
char QSslSocket_EventFilterDefault(void* ptr, void* watched, void* event);
void* QSslSocket_MetaObject(void* ptr);
void* QSslSocket_MetaObjectDefault(void* ptr);
void* QTcpServer_NewQTcpServer(void* parent);
void QTcpServer_ConnectAcceptError(void* ptr);
void QTcpServer_DisconnectAcceptError(void* ptr);
void QTcpServer_AcceptError(void* ptr, long long socketError);
void QTcpServer_AddPendingConnection(void* ptr, void* socket);
void QTcpServer_Close(void* ptr);
struct QtNetwork_PackedString QTcpServer_ErrorString(void* ptr);
char QTcpServer_HasPendingConnections(void* ptr);
char QTcpServer_HasPendingConnectionsDefault(void* ptr);
;
;
char QTcpServer_IsListening(void* ptr);
char QTcpServer_Listen(void* ptr, void* address, unsigned short port);
int QTcpServer_MaxPendingConnections(void* ptr);
void QTcpServer_ConnectNewConnection(void* ptr);
void QTcpServer_DisconnectNewConnection(void* ptr);
void QTcpServer_NewConnection(void* ptr);
void* QTcpServer_NextPendingConnection(void* ptr);
void* QTcpServer_NextPendingConnectionDefault(void* ptr);
void QTcpServer_PauseAccepting(void* ptr);
void* QTcpServer_Proxy(void* ptr);
void QTcpServer_ResumeAccepting(void* ptr);
void* QTcpServer_ServerAddress(void* ptr);
long long QTcpServer_ServerError(void* ptr);
unsigned short QTcpServer_ServerPort(void* ptr);
void QTcpServer_SetMaxPendingConnections(void* ptr, int numConnections);
void QTcpServer_SetProxy(void* ptr, void* networkProxy);
char QTcpServer_WaitForNewConnection(void* ptr, int msec, char timedOut);
void QTcpServer_DestroyQTcpServer(void* ptr);
void QTcpServer_DestroyQTcpServerDefault(void* ptr);
void QTcpServer_TimerEvent(void* ptr, void* event);
void QTcpServer_TimerEventDefault(void* ptr, void* event);
void QTcpServer_ChildEvent(void* ptr, void* event);
void QTcpServer_ChildEventDefault(void* ptr, void* event);
void QTcpServer_ConnectNotify(void* ptr, void* sign);
void QTcpServer_ConnectNotifyDefault(void* ptr, void* sign);
void QTcpServer_CustomEvent(void* ptr, void* event);
void QTcpServer_CustomEventDefault(void* ptr, void* event);
void QTcpServer_DeleteLater(void* ptr);
void QTcpServer_DeleteLaterDefault(void* ptr);
void QTcpServer_DisconnectNotify(void* ptr, void* sign);
void QTcpServer_DisconnectNotifyDefault(void* ptr, void* sign);
char QTcpServer_Event(void* ptr, void* e);
char QTcpServer_EventDefault(void* ptr, void* e);
char QTcpServer_EventFilter(void* ptr, void* watched, void* event);
char QTcpServer_EventFilterDefault(void* ptr, void* watched, void* event);
void* QTcpServer_MetaObject(void* ptr);
void* QTcpServer_MetaObjectDefault(void* ptr);
void* QTcpSocket_NewQTcpSocket(void* parent);
void QTcpSocket_DestroyQTcpSocket(void* ptr);
void QTcpSocket_DestroyQTcpSocketDefault(void* ptr);
char QTcpSocket_AtEnd(void* ptr);
char QTcpSocket_AtEndDefault(void* ptr);
long long QTcpSocket_BytesAvailable(void* ptr);
long long QTcpSocket_BytesAvailableDefault(void* ptr);
long long QTcpSocket_BytesToWrite(void* ptr);
long long QTcpSocket_BytesToWriteDefault(void* ptr);
char QTcpSocket_CanReadLine(void* ptr);
char QTcpSocket_CanReadLineDefault(void* ptr);
void QTcpSocket_Close(void* ptr);
void QTcpSocket_CloseDefault(void* ptr);
void QTcpSocket_ConnectToHost2(void* ptr, void* address, unsigned short port, long long openMode);
void QTcpSocket_ConnectToHost2Default(void* ptr, void* address, unsigned short port, long long openMode);
void QTcpSocket_ConnectToHost(void* ptr, char* hostName, unsigned short port, long long openMode, long long protocol);
void QTcpSocket_ConnectToHostDefault(void* ptr, char* hostName, unsigned short port, long long openMode, long long protocol);
void QTcpSocket_DisconnectFromHost(void* ptr);
void QTcpSocket_DisconnectFromHostDefault(void* ptr);
char QTcpSocket_IsSequential(void* ptr);
char QTcpSocket_IsSequentialDefault(void* ptr);
long long QTcpSocket_ReadLineData(void* ptr, char* data, long long maxlen);
long long QTcpSocket_ReadLineDataDefault(void* ptr, char* data, long long maxlen);
void QTcpSocket_Resume(void* ptr);
void QTcpSocket_ResumeDefault(void* ptr);
void QTcpSocket_SetReadBufferSize(void* ptr, long long size);
void QTcpSocket_SetReadBufferSizeDefault(void* ptr, long long size);
;
;
void QTcpSocket_SetSocketOption(void* ptr, long long option, void* value);
void QTcpSocket_SetSocketOptionDefault(void* ptr, long long option, void* value);
;
;
void* QTcpSocket_SocketOption(void* ptr, long long option);
void* QTcpSocket_SocketOptionDefault(void* ptr, long long option);
char QTcpSocket_WaitForBytesWritten(void* ptr, int msecs);
char QTcpSocket_WaitForBytesWrittenDefault(void* ptr, int msecs);
char QTcpSocket_WaitForConnected(void* ptr, int msecs);
char QTcpSocket_WaitForConnectedDefault(void* ptr, int msecs);
char QTcpSocket_WaitForDisconnected(void* ptr, int msecs);
char QTcpSocket_WaitForDisconnectedDefault(void* ptr, int msecs);
char QTcpSocket_WaitForReadyRead(void* ptr, int msecs);
char QTcpSocket_WaitForReadyReadDefault(void* ptr, int msecs);
long long QTcpSocket_WriteData(void* ptr, char* data, long long size);
long long QTcpSocket_WriteDataDefault(void* ptr, char* data, long long size);
char QTcpSocket_Open(void* ptr, long long mode);
char QTcpSocket_OpenDefault(void* ptr, long long mode);
long long QTcpSocket_Pos(void* ptr);
long long QTcpSocket_PosDefault(void* ptr);
char QTcpSocket_Reset(void* ptr);
char QTcpSocket_ResetDefault(void* ptr);
char QTcpSocket_Seek(void* ptr, long long pos);
char QTcpSocket_SeekDefault(void* ptr, long long pos);
long long QTcpSocket_Size(void* ptr);
long long QTcpSocket_SizeDefault(void* ptr);
void QTcpSocket_TimerEvent(void* ptr, void* event);
void QTcpSocket_TimerEventDefault(void* ptr, void* event);
void QTcpSocket_ChildEvent(void* ptr, void* event);
void QTcpSocket_ChildEventDefault(void* ptr, void* event);
void QTcpSocket_ConnectNotify(void* ptr, void* sign);
void QTcpSocket_ConnectNotifyDefault(void* ptr, void* sign);
void QTcpSocket_CustomEvent(void* ptr, void* event);
void QTcpSocket_CustomEventDefault(void* ptr, void* event);
void QTcpSocket_DeleteLater(void* ptr);
void QTcpSocket_DeleteLaterDefault(void* ptr);
void QTcpSocket_DisconnectNotify(void* ptr, void* sign);
void QTcpSocket_DisconnectNotifyDefault(void* ptr, void* sign);
char QTcpSocket_Event(void* ptr, void* e);
char QTcpSocket_EventDefault(void* ptr, void* e);
char QTcpSocket_EventFilter(void* ptr, void* watched, void* event);
char QTcpSocket_EventFilterDefault(void* ptr, void* watched, void* event);
void* QTcpSocket_MetaObject(void* ptr);
void* QTcpSocket_MetaObjectDefault(void* ptr);
void* QUdpSocket_NewQUdpSocket(void* parent);
char QUdpSocket_HasPendingDatagrams(void* ptr);
char QUdpSocket_JoinMulticastGroup(void* ptr, void* groupAddress);
char QUdpSocket_JoinMulticastGroup2(void* ptr, void* groupAddress, void* iface);
char QUdpSocket_LeaveMulticastGroup(void* ptr, void* groupAddress);
char QUdpSocket_LeaveMulticastGroup2(void* ptr, void* groupAddress, void* iface);
void* QUdpSocket_MulticastInterface(void* ptr);
long long QUdpSocket_PendingDatagramSize(void* ptr);
long long QUdpSocket_ReadDatagram(void* ptr, char* data, long long maxSize, void* address, unsigned short port);
void QUdpSocket_SetMulticastInterface(void* ptr, void* iface);
long long QUdpSocket_WriteDatagram2(void* ptr, void* datagram, void* host, unsigned short port);
long long QUdpSocket_WriteDatagram(void* ptr, char* data, long long size, void* address, unsigned short port);
void QUdpSocket_DestroyQUdpSocket(void* ptr);
void QUdpSocket_DestroyQUdpSocketDefault(void* ptr);
char QUdpSocket_AtEnd(void* ptr);
char QUdpSocket_AtEndDefault(void* ptr);
long long QUdpSocket_BytesAvailable(void* ptr);
long long QUdpSocket_BytesAvailableDefault(void* ptr);
long long QUdpSocket_BytesToWrite(void* ptr);
long long QUdpSocket_BytesToWriteDefault(void* ptr);
char QUdpSocket_CanReadLine(void* ptr);
char QUdpSocket_CanReadLineDefault(void* ptr);
void QUdpSocket_Close(void* ptr);
void QUdpSocket_CloseDefault(void* ptr);
void QUdpSocket_ConnectToHost2(void* ptr, void* address, unsigned short port, long long openMode);
void QUdpSocket_ConnectToHost2Default(void* ptr, void* address, unsigned short port, long long openMode);
void QUdpSocket_ConnectToHost(void* ptr, char* hostName, unsigned short port, long long openMode, long long protocol);
void QUdpSocket_ConnectToHostDefault(void* ptr, char* hostName, unsigned short port, long long openMode, long long protocol);
void QUdpSocket_DisconnectFromHost(void* ptr);
void QUdpSocket_DisconnectFromHostDefault(void* ptr);
char QUdpSocket_IsSequential(void* ptr);
char QUdpSocket_IsSequentialDefault(void* ptr);
long long QUdpSocket_ReadLineData(void* ptr, char* data, long long maxlen);
long long QUdpSocket_ReadLineDataDefault(void* ptr, char* data, long long maxlen);
void QUdpSocket_Resume(void* ptr);
void QUdpSocket_ResumeDefault(void* ptr);
void QUdpSocket_SetReadBufferSize(void* ptr, long long size);
void QUdpSocket_SetReadBufferSizeDefault(void* ptr, long long size);
;
;
void QUdpSocket_SetSocketOption(void* ptr, long long option, void* value);
void QUdpSocket_SetSocketOptionDefault(void* ptr, long long option, void* value);
;
;
void* QUdpSocket_SocketOption(void* ptr, long long option);
void* QUdpSocket_SocketOptionDefault(void* ptr, long long option);
char QUdpSocket_WaitForBytesWritten(void* ptr, int msecs);
char QUdpSocket_WaitForBytesWrittenDefault(void* ptr, int msecs);
char QUdpSocket_WaitForConnected(void* ptr, int msecs);
char QUdpSocket_WaitForConnectedDefault(void* ptr, int msecs);
char QUdpSocket_WaitForDisconnected(void* ptr, int msecs);
char QUdpSocket_WaitForDisconnectedDefault(void* ptr, int msecs);
char QUdpSocket_WaitForReadyRead(void* ptr, int msecs);
char QUdpSocket_WaitForReadyReadDefault(void* ptr, int msecs);
long long QUdpSocket_WriteData(void* ptr, char* data, long long size);
long long QUdpSocket_WriteDataDefault(void* ptr, char* data, long long size);
char QUdpSocket_Open(void* ptr, long long mode);
char QUdpSocket_OpenDefault(void* ptr, long long mode);
long long QUdpSocket_Pos(void* ptr);
long long QUdpSocket_PosDefault(void* ptr);
char QUdpSocket_Reset(void* ptr);
char QUdpSocket_ResetDefault(void* ptr);
char QUdpSocket_Seek(void* ptr, long long pos);
char QUdpSocket_SeekDefault(void* ptr, long long pos);
long long QUdpSocket_Size(void* ptr);
long long QUdpSocket_SizeDefault(void* ptr);
void QUdpSocket_TimerEvent(void* ptr, void* event);
void QUdpSocket_TimerEventDefault(void* ptr, void* event);
void QUdpSocket_ChildEvent(void* ptr, void* event);
void QUdpSocket_ChildEventDefault(void* ptr, void* event);
void QUdpSocket_ConnectNotify(void* ptr, void* sign);
void QUdpSocket_ConnectNotifyDefault(void* ptr, void* sign);
void QUdpSocket_CustomEvent(void* ptr, void* event);
void QUdpSocket_CustomEventDefault(void* ptr, void* event);
void QUdpSocket_DeleteLater(void* ptr);
void QUdpSocket_DeleteLaterDefault(void* ptr);
void QUdpSocket_DisconnectNotify(void* ptr, void* sign);
void QUdpSocket_DisconnectNotifyDefault(void* ptr, void* sign);
char QUdpSocket_Event(void* ptr, void* e);
char QUdpSocket_EventDefault(void* ptr, void* e);
char QUdpSocket_EventFilter(void* ptr, void* watched, void* event);
char QUdpSocket_EventFilterDefault(void* ptr, void* watched, void* event);
void* QUdpSocket_MetaObject(void* ptr);
void* QUdpSocket_MetaObjectDefault(void* ptr);

#ifdef __cplusplus
}
#endif

#endif